scisharp
/
TensorFlow.NET
Not watched
1
0
Fork 0
Code
Releases 21 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: f3a51daba4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f3a51daba4'
${ noResults }
TensorFlow.NET/src/TensorFlowNET.Core/Protobuf/Config.cs

5866 lines
245 kB
Raw Blame History 

  1. // <auto-generated>

  2. //     Generated by the protocol buffer compiler.  DO NOT EDIT!

  3. //     source: tensorflow/core/protobuf/config.proto

  4. // </auto-generated>

  5. #pragma warning disable 1591, 0612, 3021

  6. #region Designer generated code

  7. 

  8. using pb = global::Google.Protobuf;

  9. using pbc = global::Google.Protobuf.Collections;

  10. using pbr = global::Google.Protobuf.Reflection;

  11. using scg = global::System.Collections.Generic;

  12. namespace Tensorflow {

  13. 

  14.   /// <summary>Holder for reflection information generated from tensorflow/core/protobuf/config.proto</summary>

  15.   public static partial class ConfigReflection {

  16. 

  17.     #region Descriptor

  18.     /// <summary>File descriptor for tensorflow/core/protobuf/config.proto</summary>

  19.     public static pbr::FileDescriptor Descriptor {

  20.       get { return descriptor; }

  21.     }

  22.     private static pbr::FileDescriptor descriptor;

  23. 

  24.     static ConfigReflection() {

  25.       byte[] descriptorData = global::System.Convert.FromBase64String(

  26.           string.Concat(

  27.             "CiV0ZW5zb3JmbG93L2NvcmUvcHJvdG9idWYvY29uZmlnLnByb3RvEgp0ZW5z",

  28.             "b3JmbG93Gip0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL2Nvc3RfZ3JhcGgu",

  29.             "cHJvdG8aJXRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvZ3JhcGgucHJvdG8a",

  30.             "KnRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvc3RlcF9zdGF0cy5wcm90bxom",

  31.             "dGVuc29yZmxvdy9jb3JlL3Byb3RvYnVmL2NsdXN0ZXIucHJvdG8aJHRlbnNv",

  32.             "cmZsb3cvY29yZS9wcm90b2J1Zi9kZWJ1Zy5wcm90bxoudGVuc29yZmxvdy9j",

  33.             "b3JlL3Byb3RvYnVmL3Jld3JpdGVyX2NvbmZpZy5wcm90byKRBgoKR1BVT3B0",

  34.             "aW9ucxInCh9wZXJfcHJvY2Vzc19ncHVfbWVtb3J5X2ZyYWN0aW9uGAEgASgB",

  35.             "EhQKDGFsbG93X2dyb3d0aBgEIAEoCBIWCg5hbGxvY2F0b3JfdHlwZRgCIAEo",

  36.             "CRIfChdkZWZlcnJlZF9kZWxldGlvbl9ieXRlcxgDIAEoAxIbChN2aXNpYmxl",

  37.             "X2RldmljZV9saXN0GAUgASgJEiIKGnBvbGxpbmdfYWN0aXZlX2RlbGF5X3Vz",

  38.             "ZWNzGAYgASgFEiQKHHBvbGxpbmdfaW5hY3RpdmVfZGVsYXlfbXNlY3MYByAB",

  39.             "KAUSHAoUZm9yY2VfZ3B1X2NvbXBhdGlibGUYCCABKAgSOQoMZXhwZXJpbWVu",

  40.             "dGFsGAkgASgLMiMudGVuc29yZmxvdy5HUFVPcHRpb25zLkV4cGVyaW1lbnRh",

  41.             "bBrKAwoMRXhwZXJpbWVudGFsEksKD3ZpcnR1YWxfZGV2aWNlcxgBIAMoCzIy",

  42.             "LnRlbnNvcmZsb3cuR1BVT3B0aW9ucy5FeHBlcmltZW50YWwuVmlydHVhbERl",

  43.             "dmljZXMSGgoSdXNlX3VuaWZpZWRfbWVtb3J5GAIgASgIEiMKG251bV9kZXZf",

  44.             "dG9fZGV2X2NvcHlfc3RyZWFtcxgDIAEoBRIdChVjb2xsZWN0aXZlX3Jpbmdf",

  45.             "b3JkZXIYBCABKAkSHQoVdGltZXN0YW1wZWRfYWxsb2NhdG9yGAUgASgIEiMK",

  46.             "G2tlcm5lbF90cmFja2VyX21heF9pbnRlcnZhbBgHIAEoBRIgChhrZXJuZWxf",

  47.             "dHJhY2tlcl9tYXhfYnl0ZXMYCCABKAUSIgoaa2VybmVsX3RyYWNrZXJfbWF4",

  48.             "X3BlbmRpbmcYCSABKAUSJwofaW50ZXJuYWxfZnJhZ21lbnRhdGlvbl9mcmFj",

  49.             "dGlvbhgKIAEoARIdChV1c2VfY3VkYV9tYWxsb2NfYXN5bmMYCyABKAgaOwoO",

  50.             "VmlydHVhbERldmljZXMSFwoPbWVtb3J5X2xpbWl0X21iGAEgAygCEhAKCHBy",

  51.             "aW9yaXR5GAIgAygFIoUDChBPcHRpbWl6ZXJPcHRpb25zEisKI2RvX2NvbW1v",

  52.             "bl9zdWJleHByZXNzaW9uX2VsaW1pbmF0aW9uGAEgASgIEhsKE2RvX2NvbnN0",

  53.             "YW50X2ZvbGRpbmcYAiABKAgSJAocbWF4X2ZvbGRlZF9jb25zdGFudF9pbl9i",

  54.             "eXRlcxgGIAEoAxIcChRkb19mdW5jdGlvbl9pbmxpbmluZxgEIAEoCBI1Cglv",

  55.             "cHRfbGV2ZWwYAyABKA4yIi50ZW5zb3JmbG93Lk9wdGltaXplck9wdGlvbnMu",

  56.             "TGV2ZWwSRQoQZ2xvYmFsX2ppdF9sZXZlbBgFIAEoDjIrLnRlbnNvcmZsb3cu",

  57.             "T3B0aW1pemVyT3B0aW9ucy5HbG9iYWxKaXRMZXZlbCIgCgVMZXZlbBIGCgJM",

  58.             "MRAAEg8KAkwwEP///////////wEiQwoOR2xvYmFsSml0TGV2ZWwSCwoHREVG",

  59.             "QVVMVBAAEhAKA09GRhD///////////8BEggKBE9OXzEQARIICgRPTl8yEAIi",

  60.             "7gIKDEdyYXBoT3B0aW9ucxIeChZlbmFibGVfcmVjdl9zY2hlZHVsaW5nGAIg",

  61.             "ASgIEjcKEW9wdGltaXplcl9vcHRpb25zGAMgASgLMhwudGVuc29yZmxvdy5P",

  62.             "cHRpbWl6ZXJPcHRpb25zEhgKEGJ1aWxkX2Nvc3RfbW9kZWwYBCABKAMSHgoW",

  63.             "YnVpbGRfY29zdF9tb2RlbF9hZnRlchgJIAEoAxIUCgxpbmZlcl9zaGFwZXMY",

  64.             "BSABKAgSGgoScGxhY2VfcHJ1bmVkX2dyYXBoGAYgASgIEiAKGGVuYWJsZV9i",

  65.             "ZmxvYXQxNl9zZW5kcmVjdhgHIAEoCBIVCg10aW1lbGluZV9zdGVwGAggASgF",

  66.             "EjMKD3Jld3JpdGVfb3B0aW9ucxgKIAEoCzIaLnRlbnNvcmZsb3cuUmV3cml0",

  67.             "ZXJDb25maWdKBAgBEAJSJXNraXBfY29tbW9uX3N1YmV4cHJlc3Npb25fZWxp",

  68.             "bWluYXRpb24iQQoVVGhyZWFkUG9vbE9wdGlvblByb3RvEhMKC251bV90aHJl",

  69.             "YWRzGAEgASgFEhMKC2dsb2JhbF9uYW1lGAIgASgJItUBCgpSUENPcHRpb25z",

  70.             "EiQKHHVzZV9ycGNfZm9yX2lucHJvY2Vzc19tYXN0ZXIYASABKAgSHQoVY29t",

  71.             "cHJlc3Npb25fYWxnb3JpdGhtGAIgASgJEhkKEWNvbXByZXNzaW9uX2xldmVs",

  72.             "GAMgASgFEhoKEmNhY2hlX3JwY19yZXNwb25zZRgEIAEoCBIqCiJkaXNhYmxl",

  73.             "X3Nlc3Npb25fY29ubmVjdGlvbl9zaGFyaW5nGAUgASgIEh8KF251bV9jaGFu",

  74.             "bmVsc19wZXJfdGFyZ2V0GAYgASgFIjAKD1Nlc3Npb25NZXRhZGF0YRIMCgRu",

  75.             "YW1lGAEgASgJEg8KB3ZlcnNpb24YAiABKAMi2A0KC0NvbmZpZ1Byb3RvEj4K",

  76.             "DGRldmljZV9jb3VudBgBIAMoCzIoLnRlbnNvcmZsb3cuQ29uZmlnUHJvdG8u",

  77.             "RGV2aWNlQ291bnRFbnRyeRIkChxpbnRyYV9vcF9wYXJhbGxlbGlzbV90aHJl",

  78.             "YWRzGAIgASgFEiQKHGludGVyX29wX3BhcmFsbGVsaXNtX3RocmVhZHMYBSAB",

  79.             "KAUSHwoXdXNlX3Blcl9zZXNzaW9uX3RocmVhZHMYCSABKAgSRwocc2Vzc2lv",

  80.             "bl9pbnRlcl9vcF90aHJlYWRfcG9vbBgMIAMoCzIhLnRlbnNvcmZsb3cuVGhy",

  81.             "ZWFkUG9vbE9wdGlvblByb3RvEhgKEHBsYWNlbWVudF9wZXJpb2QYAyABKAUS",

  82.             "FgoOZGV2aWNlX2ZpbHRlcnMYBCADKAkSKwoLZ3B1X29wdGlvbnMYBiABKAsy",

  83.             "Fi50ZW5zb3JmbG93LkdQVU9wdGlvbnMSHAoUYWxsb3dfc29mdF9wbGFjZW1l",

  84.             "bnQYByABKAgSHAoUbG9nX2RldmljZV9wbGFjZW1lbnQYCCABKAgSLwoNZ3Jh",

  85.             "cGhfb3B0aW9ucxgKIAEoCzIYLnRlbnNvcmZsb3cuR3JhcGhPcHRpb25zEh8K",

  86.             "F29wZXJhdGlvbl90aW1lb3V0X2luX21zGAsgASgDEisKC3JwY19vcHRpb25z",

  87.             "GA0gASgLMhYudGVuc29yZmxvdy5SUENPcHRpb25zEisKC2NsdXN0ZXJfZGVm",

  88.             "GA4gASgLMhYudGVuc29yZmxvdy5DbHVzdGVyRGVmEh0KFWlzb2xhdGVfc2Vz",

  89.             "c2lvbl9zdGF0ZRgPIAEoCBIoCiBzaGFyZV9jbHVzdGVyX2RldmljZXNfaW5f",

  90.             "c2Vzc2lvbhgRIAEoCBI6CgxleHBlcmltZW50YWwYECABKAsyJC50ZW5zb3Jm",

  91.             "bG93LkNvbmZpZ1Byb3RvLkV4cGVyaW1lbnRhbBoyChBEZXZpY2VDb3VudEVu",

  92.             "dHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoBToCOAEa0gcKDEV4cGVy",

  93.             "aW1lbnRhbBIfChdjb2xsZWN0aXZlX2dyb3VwX2xlYWRlchgBIAEoCRIVCg1l",

  94.             "eGVjdXRvcl90eXBlGAMgASgJEhoKEnJlY3ZfYnVmX21heF9jaHVuaxgEIAEo",

  95.             "BRIZChF1c2VfbnVtYV9hZmZpbml0eRgFIAEoCBI1Ci1jb2xsZWN0aXZlX2Rl",

  96.             "dGVybWluaXN0aWNfc2VxdWVudGlhbF9leGVjdXRpb24YBiABKAgSFwoPY29s",

  97.             "bGVjdGl2ZV9uY2NsGAcgASgIEjYKLnNoYXJlX3Nlc3Npb25fc3RhdGVfaW5f",

  98.             "Y2x1c3RlcnNwZWNfcHJvcGFnYXRpb24YCCABKAgSHwoXZGlzYWJsZV90aHJl",

  99.             "YWRfc3Bpbm5pbmcYCSABKAgSKAogc2hhcmVfY2x1c3Rlcl9kZXZpY2VzX2lu",

  100.             "X3Nlc3Npb24YCiABKAgSNQoQc2Vzc2lvbl9tZXRhZGF0YRgLIAEoCzIbLnRl",

  101.             "bnNvcmZsb3cuU2Vzc2lvbk1ldGFkYXRhEiEKGW9wdGltaXplX2Zvcl9zdGF0",

  102.             "aWNfZ3JhcGgYDCABKAgSGgoSZW5hYmxlX21saXJfYnJpZGdlGA0gASgIElMK",

  103.             "E21saXJfYnJpZGdlX3JvbGxvdXQYESABKA4yNi50ZW5zb3JmbG93LkNvbmZp",

  104.             "Z1Byb3RvLkV4cGVyaW1lbnRhbC5NbGlyQnJpZGdlUm9sbG91dBImCh5lbmFi",

  105.             "bGVfbWxpcl9ncmFwaF9vcHRpbWl6YXRpb24YECABKAgSJwofZGlzYWJsZV9v",

  106.             "dXRwdXRfcGFydGl0aW9uX2dyYXBocxgOIAEoCBIjCht4bGFfZnVzaW9uX2F1",

  107.             "dG90dW5lcl90aHJlc2gYDyABKAMSEAoIdXNlX3RmcnQYEiABKAgSHAoUY29v",

  108.             "cmRpbmF0aW9uX3NlcnZpY2UYEyABKAkSLAokZmV0Y2hfcmVtb3RlX2Rldmlj",

  109.             "ZXNfaW5fbXVsdGlfY2xpZW50GBQgASgIItoBChFNbGlyQnJpZGdlUm9sbG91",

  110.             "dBIjCh9NTElSX0JSSURHRV9ST0xMT1VUX1VOU1BFQ0lGSUVEEAASHwobTUxJ",

  111.             "Ul9CUklER0VfUk9MTE9VVF9FTkFCTEVEEAESIAocTUxJUl9CUklER0VfUk9M",

  112.             "TE9VVF9ESVNBQkxFRBACEikKJU1MSVJfQlJJREdFX1JPTExPVVRfU0FGRV9N",

  113.             "T0RFX0VOQUJMRUQQAxIyCi5NTElSX0JSSURHRV9ST0xMT1VUX1NBRkVfTU9E",

  114.             "RV9GQUxMQkFDS19FTkFCTEVEEARKBAgCEAMi4QQKClJ1bk9wdGlvbnMSNgoL",

  115.             "dHJhY2VfbGV2ZWwYASABKA4yIS50ZW5zb3JmbG93LlJ1bk9wdGlvbnMuVHJh",

  116.             "Y2VMZXZlbBIVCg10aW1lb3V0X2luX21zGAIgASgDEhwKFGludGVyX29wX3Ro",

  117.             "cmVhZF9wb29sGAMgASgFEh8KF291dHB1dF9wYXJ0aXRpb25fZ3JhcGhzGAUg",

  118.             "ASgIEi8KDWRlYnVnX29wdGlvbnMYBiABKAsyGC50ZW5zb3JmbG93LkRlYnVn",

  119.             "T3B0aW9ucxIqCiJyZXBvcnRfdGVuc29yX2FsbG9jYXRpb25zX3Vwb25fb29t",

  120.             "GAcgASgIEjkKDGV4cGVyaW1lbnRhbBgIIAEoCzIjLnRlbnNvcmZsb3cuUnVu",

  121.             "T3B0aW9ucy5FeHBlcmltZW50YWwa0gEKDEV4cGVyaW1lbnRhbBIcChRjb2xs",

  122.             "ZWN0aXZlX2dyYXBoX2tleRgBIAEoAxIcChR1c2VfcnVuX2hhbmRsZXJfcG9v",

  123.             "bBgCIAEoCBJbChhydW5faGFuZGxlcl9wb29sX29wdGlvbnMYAyABKAsyOS50",

  124.             "ZW5zb3JmbG93LlJ1bk9wdGlvbnMuRXhwZXJpbWVudGFsLlJ1bkhhbmRsZXJQ",

  125.             "b29sT3B0aW9ucxopChVSdW5IYW5kbGVyUG9vbE9wdGlvbnMSEAoIcHJpb3Jp",

  126.             "dHkYASABKAMiUgoKVHJhY2VMZXZlbBIMCghOT19UUkFDRRAAEhIKDlNPRlRX",

  127.             "QVJFX1RSQUNFEAESEgoOSEFSRFdBUkVfVFJBQ0UQAhIOCgpGVUxMX1RSQUNF",

  128.             "EANKBAgEEAUihwMKC1J1bk1ldGFkYXRhEikKCnN0ZXBfc3RhdHMYASABKAsy",

  129.             "FS50ZW5zb3JmbG93LlN0ZXBTdGF0cxIsCgpjb3N0X2dyYXBoGAIgASgLMhgu",

  130.             "dGVuc29yZmxvdy5Db3N0R3JhcGhEZWYSLgoQcGFydGl0aW9uX2dyYXBocxgD",

  131.             "IAMoCzIULnRlbnNvcmZsb3cuR3JhcGhEZWYSPwoPZnVuY3Rpb25fZ3JhcGhz",

  132.             "GAQgAygLMiYudGVuc29yZmxvdy5SdW5NZXRhZGF0YS5GdW5jdGlvbkdyYXBo",

  133.             "cxqtAQoORnVuY3Rpb25HcmFwaHMSLgoQcGFydGl0aW9uX2dyYXBocxgBIAMo",

  134.             "CzIULnRlbnNvcmZsb3cuR3JhcGhEZWYSNAoWcHJlX29wdGltaXphdGlvbl9n",

  135.             "cmFwaBgCIAEoCzIULnRlbnNvcmZsb3cuR3JhcGhEZWYSNQoXcG9zdF9vcHRp",

  136.             "bWl6YXRpb25fZ3JhcGgYAyABKAsyFC50ZW5zb3JmbG93LkdyYXBoRGVmIjoK",

  137.             "EFRlbnNvckNvbm5lY3Rpb24SEwoLZnJvbV90ZW5zb3IYASABKAkSEQoJdG9f",

  138.             "dGVuc29yGAIgASgJIrADCg9DYWxsYWJsZU9wdGlvbnMSDAoEZmVlZBgBIAMo",

  139.             "CRINCgVmZXRjaBgCIAMoCRIOCgZ0YXJnZXQYAyADKAkSKwoLcnVuX29wdGlv",

  140.             "bnMYBCABKAsyFi50ZW5zb3JmbG93LlJ1bk9wdGlvbnMSNwoRdGVuc29yX2Nv",

  141.             "bm5lY3Rpb24YBSADKAsyHC50ZW5zb3JmbG93LlRlbnNvckNvbm5lY3Rpb24S",

  142.             "QgoMZmVlZF9kZXZpY2VzGAYgAygLMiwudGVuc29yZmxvdy5DYWxsYWJsZU9w",

  143.             "dGlvbnMuRmVlZERldmljZXNFbnRyeRJECg1mZXRjaF9kZXZpY2VzGAcgAygL",

  144.             "Mi0udGVuc29yZmxvdy5DYWxsYWJsZU9wdGlvbnMuRmV0Y2hEZXZpY2VzRW50",

  145.             "cnkSFwoPZmV0Y2hfc2tpcF9zeW5jGAggASgIGjIKEEZlZWREZXZpY2VzRW50",

  146.             "cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ARozChFGZXRjaERl",

  147.             "dmljZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBQoQB",

  148.             "ChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCDENvbmZpZ1Byb3Rvc1ABWlVn",

  149.             "aXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90ZW5zb3JmbG93L2dv",

  150.             "L2NvcmUvcHJvdG9idWYvZm9yX2NvcmVfcHJvdG9zX2dvX3Byb3Rv+AEBYgZw",

  151.             "cm90bzM="));

  152.       descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,

  153.           new pbr::FileDescriptor[] { global::Tensorflow.CostGraphReflection.Descriptor, global::Tensorflow.GraphReflection.Descriptor, global::Tensorflow.StepStatsReflection.Descriptor, global::Tensorflow.ClusterReflection.Descriptor, global::Tensorflow.DebugReflection.Descriptor, global::Tensorflow.RewriterConfigReflection.Descriptor, },

  154.           new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {

  155.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.GPUOptions), global::Tensorflow.GPUOptions.Parser, new[]{ "PerProcessGpuMemoryFraction", "AllowGrowth", "AllocatorType", "DeferredDeletionBytes", "VisibleDeviceList", "PollingActiveDelayUsecs", "PollingInactiveDelayMsecs", "ForceGpuCompatible", "Experimental" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.GPUOptions.Types.Experimental), global::Tensorflow.GPUOptions.Types.Experimental.Parser, new[]{ "VirtualDevices", "UseUnifiedMemory", "NumDevToDevCopyStreams", "CollectiveRingOrder", "TimestampedAllocator", "KernelTrackerMaxInterval", "KernelTrackerMaxBytes", "KernelTrackerMaxPending", "InternalFragmentationFraction", "UseCudaMallocAsync" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.GPUOptions.Types.Experimental.Types.VirtualDevices), global::Tensorflow.GPUOptions.Types.Experimental.Types.VirtualDevices.Parser, new[]{ "MemoryLimitMb", "Priority" }, null, null, null, null)})}),

  156.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.OptimizerOptions), global::Tensorflow.OptimizerOptions.Parser, new[]{ "DoCommonSubexpressionElimination", "DoConstantFolding", "MaxFoldedConstantInBytes", "DoFunctionInlining", "OptLevel", "GlobalJitLevel" }, null, new[]{ typeof(global::Tensorflow.OptimizerOptions.Types.Level), typeof(global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel) }, null, null),

  157.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.GraphOptions), global::Tensorflow.GraphOptions.Parser, new[]{ "EnableRecvScheduling", "OptimizerOptions", "BuildCostModel", "BuildCostModelAfter", "InferShapes", "PlacePrunedGraph", "EnableBfloat16Sendrecv", "TimelineStep", "RewriteOptions" }, null, null, null, null),

  158.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.ThreadPoolOptionProto), global::Tensorflow.ThreadPoolOptionProto.Parser, new[]{ "NumThreads", "GlobalName" }, null, null, null, null),

  159.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RPCOptions), global::Tensorflow.RPCOptions.Parser, new[]{ "UseRpcForInprocessMaster", "CompressionAlgorithm", "CompressionLevel", "CacheRpcResponse", "DisableSessionConnectionSharing", "NumChannelsPerTarget" }, null, null, null, null),

  160.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.SessionMetadata), global::Tensorflow.SessionMetadata.Parser, new[]{ "Name", "Version" }, null, null, null, null),

  161.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.ConfigProto), global::Tensorflow.ConfigProto.Parser, new[]{ "DeviceCount", "IntraOpParallelismThreads", "InterOpParallelismThreads", "UsePerSessionThreads", "SessionInterOpThreadPool", "PlacementPeriod", "DeviceFilters", "GpuOptions", "AllowSoftPlacement", "LogDevicePlacement", "GraphOptions", "OperationTimeoutInMs", "RpcOptions", "ClusterDef", "IsolateSessionState", "ShareClusterDevicesInSession", "Experimental" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.ConfigProto.Types.Experimental), global::Tensorflow.ConfigProto.Types.Experimental.Parser, new[]{ "CollectiveGroupLeader", "ExecutorType", "RecvBufMaxChunk", "UseNumaAffinity", "CollectiveDeterministicSequentialExecution", "CollectiveNccl", "ShareSessionStateInClusterspecPropagation", "DisableThreadSpinning", "ShareClusterDevicesInSession", "SessionMetadata", "OptimizeForStaticGraph", "EnableMlirBridge", "MlirBridgeRollout", "EnableMlirGraphOptimization", "DisableOutputPartitionGraphs", "XlaFusionAutotunerThresh", "UseTfrt", "CoordinationService", "FetchRemoteDevicesInMultiClient" }, null, new[]{ typeof(global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout) }, null, null)}),

  162.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RunOptions), global::Tensorflow.RunOptions.Parser, new[]{ "TraceLevel", "TimeoutInMs", "InterOpThreadPool", "OutputPartitionGraphs", "DebugOptions", "ReportTensorAllocationsUponOom", "Experimental" }, null, new[]{ typeof(global::Tensorflow.RunOptions.Types.TraceLevel) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RunOptions.Types.Experimental), global::Tensorflow.RunOptions.Types.Experimental.Parser, new[]{ "CollectiveGraphKey", "UseRunHandlerPool", "RunHandlerPoolOptions" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RunOptions.Types.Experimental.Types.RunHandlerPoolOptions), global::Tensorflow.RunOptions.Types.Experimental.Types.RunHandlerPoolOptions.Parser, new[]{ "Priority" }, null, null, null, null)})}),

  163.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RunMetadata), global::Tensorflow.RunMetadata.Parser, new[]{ "StepStats", "CostGraph", "PartitionGraphs", "FunctionGraphs" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RunMetadata.Types.FunctionGraphs), global::Tensorflow.RunMetadata.Types.FunctionGraphs.Parser, new[]{ "PartitionGraphs", "PreOptimizationGraph", "PostOptimizationGraph" }, null, null, null, null)}),

  164.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.TensorConnection), global::Tensorflow.TensorConnection.Parser, new[]{ "FromTensor", "ToTensor" }, null, null, null, null),

  165.             new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.CallableOptions), global::Tensorflow.CallableOptions.Parser, new[]{ "Feed", "Fetch", "Target", "RunOptions", "TensorConnection", "FeedDevices", "FetchDevices", "FetchSkipSync" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, null, })

  166.           }));

  167.     }

  168.     #endregion

  169. 

  170.   }

  171.   #region Messages

  172.   public sealed partial class GPUOptions : pb::IMessage<GPUOptions> {

  173.     private static readonly pb::MessageParser<GPUOptions> _parser = new pb::MessageParser<GPUOptions>(() => new GPUOptions());

  174.     private pb::UnknownFieldSet _unknownFields;

  175.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  176.     public static pb::MessageParser<GPUOptions> Parser { get { return _parser; } }

  177. 

  178.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  179.     public static pbr::MessageDescriptor Descriptor {

  180.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[0]; }

  181.     }

  182. 

  183.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  184.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  185.       get { return Descriptor; }

  186.     }

  187. 

  188.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  189.     public GPUOptions() {

  190.       OnConstruction();

  191.     }

  192. 

  193.     partial void OnConstruction();

  194. 

  195.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  196.     public GPUOptions(GPUOptions other) : this() {

  197.       perProcessGpuMemoryFraction_ = other.perProcessGpuMemoryFraction_;

  198.       allowGrowth_ = other.allowGrowth_;

  199.       allocatorType_ = other.allocatorType_;

  200.       deferredDeletionBytes_ = other.deferredDeletionBytes_;

  201.       visibleDeviceList_ = other.visibleDeviceList_;

  202.       pollingActiveDelayUsecs_ = other.pollingActiveDelayUsecs_;

  203.       pollingInactiveDelayMsecs_ = other.pollingInactiveDelayMsecs_;

  204.       forceGpuCompatible_ = other.forceGpuCompatible_;

  205.       experimental_ = other.experimental_ != null ? other.experimental_.Clone() : null;

  206.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  207.     }

  208. 

  209.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  210.     public GPUOptions Clone() {

  211.       return new GPUOptions(this);

  212.     }

  213. 

  214.     /// <summary>Field number for the "per_process_gpu_memory_fraction" field.</summary>

  215.     public const int PerProcessGpuMemoryFractionFieldNumber = 1;

  216.     private double perProcessGpuMemoryFraction_;

  217.     /// <summary>

  218.     /// Fraction of the available GPU memory to allocate for each process.

  219.     /// 1 means to allocate all of the GPU memory, 0.5 means the process

  220.     /// allocates up to ~50% of the available GPU memory.

  221.     ///

  222.     /// GPU memory is pre-allocated unless the allow_growth option is enabled.

  223.     ///

  224.     /// If greater than 1.0, uses CUDA unified memory to potentially oversubscribe

  225.     /// the amount of memory available on the GPU device by using host memory as a

  226.     /// swap space. Accessing memory not available on the device will be

  227.     /// significantly slower as that would require memory transfer between the host

  228.     /// and the device. Options to reduce the memory requirement should be

  229.     /// considered before enabling this option as this may come with a negative

  230.     /// performance impact. Oversubscription using the unified memory requires

  231.     /// Pascal class or newer GPUs and it is currently only supported on the Linux

  232.     /// operating system. See

  233.     /// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#um-requirements

  234.     /// for the detailed requirements.

  235.     /// </summary>

  236.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  237.     public double PerProcessGpuMemoryFraction {

  238.       get { return perProcessGpuMemoryFraction_; }

  239.       set {

  240.         perProcessGpuMemoryFraction_ = value;

  241.       }

  242.     }

  243. 

  244.     /// <summary>Field number for the "allow_growth" field.</summary>

  245.     public const int AllowGrowthFieldNumber = 4;

  246.     private bool allowGrowth_;

  247.     /// <summary>

  248.     /// If true, the allocator does not pre-allocate the entire specified

  249.     /// GPU memory region, instead starting small and growing as needed.

  250.     /// </summary>

  251.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  252.     public bool AllowGrowth {

  253.       get { return allowGrowth_; }

  254.       set {

  255.         allowGrowth_ = value;

  256.       }

  257.     }

  258. 

  259.     /// <summary>Field number for the "allocator_type" field.</summary>

  260.     public const int AllocatorTypeFieldNumber = 2;

  261.     private string allocatorType_ = "";

  262.     /// <summary>

  263.     /// The type of GPU allocation strategy to use.

  264.     ///

  265.     /// Allowed values:

  266.     /// "": The empty string (default) uses a system-chosen default

  267.     ///     which may change over time.

  268.     ///

  269.     /// "BFC": A "Best-fit with coalescing" algorithm, simplified from a

  270.     ///        version of dlmalloc.

  271.     /// </summary>

  272.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  273.     public string AllocatorType {

  274.       get { return allocatorType_; }

  275.       set {

  276.         allocatorType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  277.       }

  278.     }

  279. 

  280.     /// <summary>Field number for the "deferred_deletion_bytes" field.</summary>

  281.     public const int DeferredDeletionBytesFieldNumber = 3;

  282.     private long deferredDeletionBytes_;

  283.     /// <summary>

  284.     /// Delay deletion of up to this many bytes to reduce the number of

  285.     /// interactions with gpu driver code.  If 0, the system chooses

  286.     /// a reasonable default (several MBs).

  287.     /// </summary>

  288.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  289.     public long DeferredDeletionBytes {

  290.       get { return deferredDeletionBytes_; }

  291.       set {

  292.         deferredDeletionBytes_ = value;

  293.       }

  294.     }

  295. 

  296.     /// <summary>Field number for the "visible_device_list" field.</summary>

  297.     public const int VisibleDeviceListFieldNumber = 5;

  298.     private string visibleDeviceList_ = "";

  299.     /// <summary>

  300.     /// A comma-separated list of GPU ids that determines the 'visible'

  301.     /// to 'virtual' mapping of GPU devices.  For example, if TensorFlow

  302.     /// can see 8 GPU devices in the process, and one wanted to map

  303.     /// visible GPU devices 5 and 3 as "/device:GPU:0", and "/device:GPU:1",

  304.     /// then one would specify this field as "5,3".  This field is similar in

  305.     /// spirit to the CUDA_VISIBLE_DEVICES environment variable, except

  306.     /// it applies to the visible GPU devices in the process.

  307.     ///

  308.     /// NOTE:

  309.     /// 1. The GPU driver provides the process with the visible GPUs

  310.     ///    in an order which is not guaranteed to have any correlation to

  311.     ///    the *physical* GPU id in the machine.  This field is used for

  312.     ///    remapping "visible" to "virtual", which means this operates only

  313.     ///    after the process starts.  Users are required to use vendor

  314.     ///    specific mechanisms (e.g., CUDA_VISIBLE_DEVICES) to control the

  315.     ///    physical to visible device mapping prior to invoking TensorFlow.

  316.     /// 2. In the code, the ids in this list are also called "platform GPU id"s,

  317.     ///    and the 'virtual' ids of GPU devices (i.e. the ids in the device

  318.     ///    name "/device:GPU:&lt;id>") are also called "TF GPU id"s. Please

  319.     ///    refer to third_party/tensorflow/core/common_runtime/gpu/gpu_id.h

  320.     ///    for more information.

  321.     /// </summary>

  322.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  323.     public string VisibleDeviceList {

  324.       get { return visibleDeviceList_; }

  325.       set {

  326.         visibleDeviceList_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  327.       }

  328.     }

  329. 

  330.     /// <summary>Field number for the "polling_active_delay_usecs" field.</summary>

  331.     public const int PollingActiveDelayUsecsFieldNumber = 6;

  332.     private int pollingActiveDelayUsecs_;

  333.     /// <summary>

  334.     /// In the event polling loop sleep this many microseconds between

  335.     /// PollEvents calls, when the queue is not empty.  If value is not

  336.     /// set or set to 0, gets set to a non-zero default.

  337.     /// </summary>

  338.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  339.     public int PollingActiveDelayUsecs {

  340.       get { return pollingActiveDelayUsecs_; }

  341.       set {

  342.         pollingActiveDelayUsecs_ = value;

  343.       }

  344.     }

  345. 

  346.     /// <summary>Field number for the "polling_inactive_delay_msecs" field.</summary>

  347.     public const int PollingInactiveDelayMsecsFieldNumber = 7;

  348.     private int pollingInactiveDelayMsecs_;

  349.     /// <summary>

  350.     /// This field is deprecated and ignored.

  351.     /// </summary>

  352.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  353.     public int PollingInactiveDelayMsecs {

  354.       get { return pollingInactiveDelayMsecs_; }

  355.       set {

  356.         pollingInactiveDelayMsecs_ = value;

  357.       }

  358.     }

  359. 

  360.     /// <summary>Field number for the "force_gpu_compatible" field.</summary>

  361.     public const int ForceGpuCompatibleFieldNumber = 8;

  362.     private bool forceGpuCompatible_;

  363.     /// <summary>

  364.     /// Force all tensors to be gpu_compatible. On a GPU-enabled TensorFlow,

  365.     /// enabling this option forces all CPU tensors to be allocated with Cuda

  366.     /// pinned memory. Normally, TensorFlow will infer which tensors should be

  367.     /// allocated as the pinned memory. But in case where the inference is

  368.     /// incomplete, this option can significantly speed up the cross-device memory

  369.     /// copy performance as long as it fits the memory.

  370.     /// Note that this option is not something that should be

  371.     /// enabled by default for unknown or very large models, since all Cuda pinned

  372.     /// memory is unpageable, having too much pinned memory might negatively impact

  373.     /// the overall host system performance.

  374.     /// </summary>

  375.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  376.     public bool ForceGpuCompatible {

  377.       get { return forceGpuCompatible_; }

  378.       set {

  379.         forceGpuCompatible_ = value;

  380.       }

  381.     }

  382. 

  383.     /// <summary>Field number for the "experimental" field.</summary>

  384.     public const int ExperimentalFieldNumber = 9;

  385.     private global::Tensorflow.GPUOptions.Types.Experimental experimental_;

  386.     /// <summary>

  387.     /// Everything inside experimental is subject to change and is not subject

  388.     /// to API stability guarantees in

  389.     /// https://www.tensorflow.org/guide/version_compat.

  390.     /// </summary>

  391.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  392.     public global::Tensorflow.GPUOptions.Types.Experimental Experimental {

  393.       get { return experimental_; }

  394.       set {

  395.         experimental_ = value;

  396.       }

  397.     }

  398. 

  399.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  400.     public override bool Equals(object other) {

  401.       return Equals(other as GPUOptions);

  402.     }

  403. 

  404.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  405.     public bool Equals(GPUOptions other) {

  406.       if (ReferenceEquals(other, null)) {

  407.         return false;

  408.       }

  409.       if (ReferenceEquals(other, this)) {

  410.         return true;

  411.       }

  412.       if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PerProcessGpuMemoryFraction, other.PerProcessGpuMemoryFraction)) return false;

  413.       if (AllowGrowth != other.AllowGrowth) return false;

  414.       if (AllocatorType != other.AllocatorType) return false;

  415.       if (DeferredDeletionBytes != other.DeferredDeletionBytes) return false;

  416.       if (VisibleDeviceList != other.VisibleDeviceList) return false;

  417.       if (PollingActiveDelayUsecs != other.PollingActiveDelayUsecs) return false;

  418.       if (PollingInactiveDelayMsecs != other.PollingInactiveDelayMsecs) return false;

  419.       if (ForceGpuCompatible != other.ForceGpuCompatible) return false;

  420.       if (!object.Equals(Experimental, other.Experimental)) return false;

  421.       return Equals(_unknownFields, other._unknownFields);

  422.     }

  423. 

  424.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  425.     public override int GetHashCode() {

  426.       int hash = 1;

  427.       if (PerProcessGpuMemoryFraction != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PerProcessGpuMemoryFraction);

  428.       if (AllowGrowth != false) hash ^= AllowGrowth.GetHashCode();

  429.       if (AllocatorType.Length != 0) hash ^= AllocatorType.GetHashCode();

  430.       if (DeferredDeletionBytes != 0L) hash ^= DeferredDeletionBytes.GetHashCode();

  431.       if (VisibleDeviceList.Length != 0) hash ^= VisibleDeviceList.GetHashCode();

  432.       if (PollingActiveDelayUsecs != 0) hash ^= PollingActiveDelayUsecs.GetHashCode();

  433.       if (PollingInactiveDelayMsecs != 0) hash ^= PollingInactiveDelayMsecs.GetHashCode();

  434.       if (ForceGpuCompatible != false) hash ^= ForceGpuCompatible.GetHashCode();

  435.       if (experimental_ != null) hash ^= Experimental.GetHashCode();

  436.       if (_unknownFields != null) {

  437.         hash ^= _unknownFields.GetHashCode();

  438.       }

  439.       return hash;

  440.     }

  441. 

  442.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  443.     public override string ToString() {

  444.       return pb::JsonFormatter.ToDiagnosticString(this);

  445.     }

  446. 

  447.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  448.     public void WriteTo(pb::CodedOutputStream output) {

  449.       if (PerProcessGpuMemoryFraction != 0D) {

  450.         output.WriteRawTag(9);

  451.         output.WriteDouble(PerProcessGpuMemoryFraction);

  452.       }

  453.       if (AllocatorType.Length != 0) {

  454.         output.WriteRawTag(18);

  455.         output.WriteString(AllocatorType);

  456.       }

  457.       if (DeferredDeletionBytes != 0L) {

  458.         output.WriteRawTag(24);

  459.         output.WriteInt64(DeferredDeletionBytes);

  460.       }

  461.       if (AllowGrowth != false) {

  462.         output.WriteRawTag(32);

  463.         output.WriteBool(AllowGrowth);

  464.       }

  465.       if (VisibleDeviceList.Length != 0) {

  466.         output.WriteRawTag(42);

  467.         output.WriteString(VisibleDeviceList);

  468.       }

  469.       if (PollingActiveDelayUsecs != 0) {

  470.         output.WriteRawTag(48);

  471.         output.WriteInt32(PollingActiveDelayUsecs);

  472.       }

  473.       if (PollingInactiveDelayMsecs != 0) {

  474.         output.WriteRawTag(56);

  475.         output.WriteInt32(PollingInactiveDelayMsecs);

  476.       }

  477.       if (ForceGpuCompatible != false) {

  478.         output.WriteRawTag(64);

  479.         output.WriteBool(ForceGpuCompatible);

  480.       }

  481.       if (experimental_ != null) {

  482.         output.WriteRawTag(74);

  483.         output.WriteMessage(Experimental);

  484.       }

  485.       if (_unknownFields != null) {

  486.         _unknownFields.WriteTo(output);

  487.       }

  488.     }

  489. 

  490.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  491.     public int CalculateSize() {

  492.       int size = 0;

  493.       if (PerProcessGpuMemoryFraction != 0D) {

  494.         size += 1 + 8;

  495.       }

  496.       if (AllowGrowth != false) {

  497.         size += 1 + 1;

  498.       }

  499.       if (AllocatorType.Length != 0) {

  500.         size += 1 + pb::CodedOutputStream.ComputeStringSize(AllocatorType);

  501.       }

  502.       if (DeferredDeletionBytes != 0L) {

  503.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(DeferredDeletionBytes);

  504.       }

  505.       if (VisibleDeviceList.Length != 0) {

  506.         size += 1 + pb::CodedOutputStream.ComputeStringSize(VisibleDeviceList);

  507.       }

  508.       if (PollingActiveDelayUsecs != 0) {

  509.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(PollingActiveDelayUsecs);

  510.       }

  511.       if (PollingInactiveDelayMsecs != 0) {

  512.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(PollingInactiveDelayMsecs);

  513.       }

  514.       if (ForceGpuCompatible != false) {

  515.         size += 1 + 1;

  516.       }

  517.       if (experimental_ != null) {

  518.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Experimental);

  519.       }

  520.       if (_unknownFields != null) {

  521.         size += _unknownFields.CalculateSize();

  522.       }

  523.       return size;

  524.     }

  525. 

  526.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  527.     public void MergeFrom(GPUOptions other) {

  528.       if (other == null) {

  529.         return;

  530.       }

  531.       if (other.PerProcessGpuMemoryFraction != 0D) {

  532.         PerProcessGpuMemoryFraction = other.PerProcessGpuMemoryFraction;

  533.       }

  534.       if (other.AllowGrowth != false) {

  535.         AllowGrowth = other.AllowGrowth;

  536.       }

  537.       if (other.AllocatorType.Length != 0) {

  538.         AllocatorType = other.AllocatorType;

  539.       }

  540.       if (other.DeferredDeletionBytes != 0L) {

  541.         DeferredDeletionBytes = other.DeferredDeletionBytes;

  542.       }

  543.       if (other.VisibleDeviceList.Length != 0) {

  544.         VisibleDeviceList = other.VisibleDeviceList;

  545.       }

  546.       if (other.PollingActiveDelayUsecs != 0) {

  547.         PollingActiveDelayUsecs = other.PollingActiveDelayUsecs;

  548.       }

  549.       if (other.PollingInactiveDelayMsecs != 0) {

  550.         PollingInactiveDelayMsecs = other.PollingInactiveDelayMsecs;

  551.       }

  552.       if (other.ForceGpuCompatible != false) {

  553.         ForceGpuCompatible = other.ForceGpuCompatible;

  554.       }

  555.       if (other.experimental_ != null) {

  556.         if (experimental_ == null) {

  557.           Experimental = new global::Tensorflow.GPUOptions.Types.Experimental();

  558.         }

  559.         Experimental.MergeFrom(other.Experimental);

  560.       }

  561.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  562.     }

  563. 

  564.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  565.     public void MergeFrom(pb::CodedInputStream input) {

  566.       uint tag;

  567.       while ((tag = input.ReadTag()) != 0) {

  568.         switch(tag) {

  569.           default:

  570.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  571.             break;

  572.           case 9: {

  573.             PerProcessGpuMemoryFraction = input.ReadDouble();

  574.             break;

  575.           }

  576.           case 18: {

  577.             AllocatorType = input.ReadString();

  578.             break;

  579.           }

  580.           case 24: {

  581.             DeferredDeletionBytes = input.ReadInt64();

  582.             break;

  583.           }

  584.           case 32: {

  585.             AllowGrowth = input.ReadBool();

  586.             break;

  587.           }

  588.           case 42: {

  589.             VisibleDeviceList = input.ReadString();

  590.             break;

  591.           }

  592.           case 48: {

  593.             PollingActiveDelayUsecs = input.ReadInt32();

  594.             break;

  595.           }

  596.           case 56: {

  597.             PollingInactiveDelayMsecs = input.ReadInt32();

  598.             break;

  599.           }

  600.           case 64: {

  601.             ForceGpuCompatible = input.ReadBool();

  602.             break;

  603.           }

  604.           case 74: {

  605.             if (experimental_ == null) {

  606.               Experimental = new global::Tensorflow.GPUOptions.Types.Experimental();

  607.             }

  608.             input.ReadMessage(Experimental);

  609.             break;

  610.           }

  611.         }

  612.       }

  613.     }

  614. 

  615.     #region Nested types

  616.     /// <summary>Container for nested types declared in the GPUOptions message type.</summary>

  617.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  618.     public static partial class Types {

  619.       public sealed partial class Experimental : pb::IMessage<Experimental> {

  620.         private static readonly pb::MessageParser<Experimental> _parser = new pb::MessageParser<Experimental>(() => new Experimental());

  621.         private pb::UnknownFieldSet _unknownFields;

  622.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  623.         public static pb::MessageParser<Experimental> Parser { get { return _parser; } }

  624. 

  625.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  626.         public static pbr::MessageDescriptor Descriptor {

  627.           get { return global::Tensorflow.GPUOptions.Descriptor.NestedTypes[0]; }

  628.         }

  629. 

  630.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  631.         pbr::MessageDescriptor pb::IMessage.Descriptor {

  632.           get { return Descriptor; }

  633.         }

  634. 

  635.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  636.         public Experimental() {

  637.           OnConstruction();

  638.         }

  639. 

  640.         partial void OnConstruction();

  641. 

  642.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  643.         public Experimental(Experimental other) : this() {

  644.           virtualDevices_ = other.virtualDevices_.Clone();

  645.           useUnifiedMemory_ = other.useUnifiedMemory_;

  646.           numDevToDevCopyStreams_ = other.numDevToDevCopyStreams_;

  647.           collectiveRingOrder_ = other.collectiveRingOrder_;

  648.           timestampedAllocator_ = other.timestampedAllocator_;

  649.           kernelTrackerMaxInterval_ = other.kernelTrackerMaxInterval_;

  650.           kernelTrackerMaxBytes_ = other.kernelTrackerMaxBytes_;

  651.           kernelTrackerMaxPending_ = other.kernelTrackerMaxPending_;

  652.           internalFragmentationFraction_ = other.internalFragmentationFraction_;

  653.           useCudaMallocAsync_ = other.useCudaMallocAsync_;

  654.           _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  655.         }

  656. 

  657.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  658.         public Experimental Clone() {

  659.           return new Experimental(this);

  660.         }

  661. 

  662.         /// <summary>Field number for the "virtual_devices" field.</summary>

  663.         public const int VirtualDevicesFieldNumber = 1;

  664.         private static readonly pb::FieldCodec<global::Tensorflow.GPUOptions.Types.Experimental.Types.VirtualDevices> _repeated_virtualDevices_codec

  665.             = pb::FieldCodec.ForMessage(10, global::Tensorflow.GPUOptions.Types.Experimental.Types.VirtualDevices.Parser);

  666.         private readonly pbc::RepeatedField<global::Tensorflow.GPUOptions.Types.Experimental.Types.VirtualDevices> virtualDevices_ = new pbc::RepeatedField<global::Tensorflow.GPUOptions.Types.Experimental.Types.VirtualDevices>();

  667.         /// <summary>

  668.         /// The multi virtual device settings. If empty (not set), it will create

  669.         /// single virtual device on each visible GPU, according to the settings

  670.         /// in "visible_device_list" above. Otherwise, the number of elements in the

  671.         /// list must be the same as the number of visible GPUs (after

  672.         /// "visible_device_list" filtering if it is set), and the string represented

  673.         /// device names (e.g. /device:GPU:&lt;id>) will refer to the virtual

  674.         /// devices and have the &lt;id> field assigned sequentially starting from 0,

  675.         /// according to the order they appear in this list and the "memory_limit"

  676.         /// list inside each element. For example,

  677.         ///   visible_device_list = "1,0"

  678.         ///   virtual_devices { memory_limit: 1GB memory_limit: 2GB }

  679.         ///   virtual_devices {}

  680.         /// will create three virtual devices as:

  681.         ///   /device:GPU:0 -> visible GPU 1 with 1GB memory

  682.         ///   /device:GPU:1 -> visible GPU 1 with 2GB memory

  683.         ///   /device:GPU:2 -> visible GPU 0 with all available memory

  684.         ///

  685.         /// NOTE:

  686.         /// 1. It's invalid to set both this and "per_process_gpu_memory_fraction"

  687.         ///    at the same time.

  688.         /// 2. Currently this setting is per-process, not per-session. Using

  689.         ///    different settings in different sessions within same process will

  690.         ///    result in undefined behavior.

  691.         /// </summary>

  692.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  693.         public pbc::RepeatedField<global::Tensorflow.GPUOptions.Types.Experimental.Types.VirtualDevices> VirtualDevices {

  694.           get { return virtualDevices_; }

  695.         }

  696. 

  697.         /// <summary>Field number for the "use_unified_memory" field.</summary>

  698.         public const int UseUnifiedMemoryFieldNumber = 2;

  699.         private bool useUnifiedMemory_;

  700.         /// <summary>

  701.         /// If true, uses CUDA unified memory for memory allocations. If

  702.         /// per_process_gpu_memory_fraction option is greater than 1.0, then unified

  703.         /// memory is used regardless of the value for this field. See comments for

  704.         /// per_process_gpu_memory_fraction field for more details and requirements

  705.         /// of the unified memory. This option is useful to oversubscribe memory if

  706.         /// multiple processes are sharing a single GPU while individually using less

  707.         /// than 1.0 per process memory fraction.

  708.         /// </summary>

  709.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  710.         public bool UseUnifiedMemory {

  711.           get { return useUnifiedMemory_; }

  712.           set {

  713.             useUnifiedMemory_ = value;

  714.           }

  715.         }

  716. 

  717.         /// <summary>Field number for the "num_dev_to_dev_copy_streams" field.</summary>

  718.         public const int NumDevToDevCopyStreamsFieldNumber = 3;

  719.         private int numDevToDevCopyStreams_;

  720.         /// <summary>

  721.         /// If > 1, the number of device-to-device copy streams to create

  722.         /// for each GPUDevice.  Default value is 0, which is automatically

  723.         /// converted to 1.

  724.         /// </summary>

  725.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  726.         public int NumDevToDevCopyStreams {

  727.           get { return numDevToDevCopyStreams_; }

  728.           set {

  729.             numDevToDevCopyStreams_ = value;

  730.           }

  731.         }

  732. 

  733.         /// <summary>Field number for the "collective_ring_order" field.</summary>

  734.         public const int CollectiveRingOrderFieldNumber = 4;

  735.         private string collectiveRingOrder_ = "";

  736.         /// <summary>

  737.         /// If non-empty, defines a good GPU ring order on a single worker based on

  738.         /// device interconnect.  This assumes that all workers have the same GPU

  739.         /// topology.  Specify as a comma-separated string, e.g. "3,2,1,0,7,6,5,4".

  740.         /// This ring order is used by the RingReducer implementation of

  741.         /// CollectiveReduce, and serves as an override to automatic ring order

  742.         /// generation in OrderTaskDeviceMap() during CollectiveParam resolution.

  743.         /// </summary>

  744.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  745.         public string CollectiveRingOrder {

  746.           get { return collectiveRingOrder_; }

  747.           set {

  748.             collectiveRingOrder_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  749.           }

  750.         }

  751. 

  752.         /// <summary>Field number for the "timestamped_allocator" field.</summary>

  753.         public const int TimestampedAllocatorFieldNumber = 5;

  754.         private bool timestampedAllocator_;

  755.         /// <summary>

  756.         /// If true then extra work is done by GPUDevice and GPUBFCAllocator to

  757.         /// keep track of when GPU memory is freed and when kernels actually

  758.         /// complete so that we can know when a nominally free memory chunk

  759.         /// is really not subject to pending use.

  760.         /// </summary>

  761.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  762.         public bool TimestampedAllocator {

  763.           get { return timestampedAllocator_; }

  764.           set {

  765.             timestampedAllocator_ = value;

  766.           }

  767.         }

  768. 

  769.         /// <summary>Field number for the "kernel_tracker_max_interval" field.</summary>

  770.         public const int KernelTrackerMaxIntervalFieldNumber = 7;

  771.         private int kernelTrackerMaxInterval_;

  772.         /// <summary>

  773.         /// Parameters for GPUKernelTracker.  By default no kernel tracking is done.

  774.         /// Note that timestamped_allocator is only effective if some tracking is

  775.         /// specified.

  776.         ///

  777.         /// If kernel_tracker_max_interval = n > 0, then a tracking event

  778.         /// is inserted after every n kernels without an event.

  779.         /// </summary>

  780.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  781.         public int KernelTrackerMaxInterval {

  782.           get { return kernelTrackerMaxInterval_; }

  783.           set {

  784.             kernelTrackerMaxInterval_ = value;

  785.           }

  786.         }

  787. 

  788.         /// <summary>Field number for the "kernel_tracker_max_bytes" field.</summary>

  789.         public const int KernelTrackerMaxBytesFieldNumber = 8;

  790.         private int kernelTrackerMaxBytes_;

  791.         /// <summary>

  792.         /// If kernel_tracker_max_bytes = n > 0, then a tracking event is

  793.         /// inserted after every series of kernels allocating a sum of

  794.         /// memory >= n.  If one kernel allocates b * n bytes, then one

  795.         /// event will be inserted after it, but it will count as b against

  796.         /// the pending limit.

  797.         /// </summary>

  798.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  799.         public int KernelTrackerMaxBytes {

  800.           get { return kernelTrackerMaxBytes_; }

  801.           set {

  802.             kernelTrackerMaxBytes_ = value;

  803.           }

  804.         }

  805. 

  806.         /// <summary>Field number for the "kernel_tracker_max_pending" field.</summary>

  807.         public const int KernelTrackerMaxPendingFieldNumber = 9;

  808.         private int kernelTrackerMaxPending_;

  809.         /// <summary>

  810.         /// If kernel_tracker_max_pending > 0 then no more than this many

  811.         /// tracking events can be outstanding at a time.  An attempt to

  812.         /// launch an additional kernel will stall until an event

  813.         /// completes.

  814.         /// </summary>

  815.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  816.         public int KernelTrackerMaxPending {

  817.           get { return kernelTrackerMaxPending_; }

  818.           set {

  819.             kernelTrackerMaxPending_ = value;

  820.           }

  821.         }

  822. 

  823.         /// <summary>Field number for the "internal_fragmentation_fraction" field.</summary>

  824.         public const int InternalFragmentationFractionFieldNumber = 10;

  825.         private double internalFragmentationFraction_;

  826.         /// <summary>

  827.         /// BFC Allocator can return an allocated chunk of memory upto 2x the

  828.         /// requested size. For virtual devices with tight memory constraints, and

  829.         /// proportionately large allocation requests, this can lead to a significant

  830.         /// reduction in available memory. The threshold below controls when a chunk

  831.         /// should be split if the chunk size exceeds requested memory size. It is

  832.         /// expressed as a fraction of total available memory for the tf device. For

  833.         /// example setting it to 0.05 would imply a chunk needs to be split if its

  834.         /// size exceeds the requested memory by 5% of the total virtual device/gpu

  835.         /// memory size.

  836.         /// </summary>

  837.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  838.         public double InternalFragmentationFraction {

  839.           get { return internalFragmentationFraction_; }

  840.           set {

  841.             internalFragmentationFraction_ = value;

  842.           }

  843.         }

  844. 

  845.         /// <summary>Field number for the "use_cuda_malloc_async" field.</summary>

  846.         public const int UseCudaMallocAsyncFieldNumber = 11;

  847.         private bool useCudaMallocAsync_;

  848.         /// <summary>

  849.         /// When true, use CUDA cudaMallocAsync API instead of TF gpu allocator.

  850.         /// </summary>

  851.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  852.         public bool UseCudaMallocAsync {

  853.           get { return useCudaMallocAsync_; }

  854.           set {

  855.             useCudaMallocAsync_ = value;

  856.           }

  857.         }

  858. 

  859.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  860.         public override bool Equals(object other) {

  861.           return Equals(other as Experimental);

  862.         }

  863. 

  864.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  865.         public bool Equals(Experimental other) {

  866.           if (ReferenceEquals(other, null)) {

  867.             return false;

  868.           }

  869.           if (ReferenceEquals(other, this)) {

  870.             return true;

  871.           }

  872.           if(!virtualDevices_.Equals(other.virtualDevices_)) return false;

  873.           if (UseUnifiedMemory != other.UseUnifiedMemory) return false;

  874.           if (NumDevToDevCopyStreams != other.NumDevToDevCopyStreams) return false;

  875.           if (CollectiveRingOrder != other.CollectiveRingOrder) return false;

  876.           if (TimestampedAllocator != other.TimestampedAllocator) return false;

  877.           if (KernelTrackerMaxInterval != other.KernelTrackerMaxInterval) return false;

  878.           if (KernelTrackerMaxBytes != other.KernelTrackerMaxBytes) return false;

  879.           if (KernelTrackerMaxPending != other.KernelTrackerMaxPending) return false;

  880.           if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InternalFragmentationFraction, other.InternalFragmentationFraction)) return false;

  881.           if (UseCudaMallocAsync != other.UseCudaMallocAsync) return false;

  882.           return Equals(_unknownFields, other._unknownFields);

  883.         }

  884. 

  885.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  886.         public override int GetHashCode() {

  887.           int hash = 1;

  888.           hash ^= virtualDevices_.GetHashCode();

  889.           if (UseUnifiedMemory != false) hash ^= UseUnifiedMemory.GetHashCode();

  890.           if (NumDevToDevCopyStreams != 0) hash ^= NumDevToDevCopyStreams.GetHashCode();

  891.           if (CollectiveRingOrder.Length != 0) hash ^= CollectiveRingOrder.GetHashCode();

  892.           if (TimestampedAllocator != false) hash ^= TimestampedAllocator.GetHashCode();

  893.           if (KernelTrackerMaxInterval != 0) hash ^= KernelTrackerMaxInterval.GetHashCode();

  894.           if (KernelTrackerMaxBytes != 0) hash ^= KernelTrackerMaxBytes.GetHashCode();

  895.           if (KernelTrackerMaxPending != 0) hash ^= KernelTrackerMaxPending.GetHashCode();

  896.           if (InternalFragmentationFraction != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InternalFragmentationFraction);

  897.           if (UseCudaMallocAsync != false) hash ^= UseCudaMallocAsync.GetHashCode();

  898.           if (_unknownFields != null) {

  899.             hash ^= _unknownFields.GetHashCode();

  900.           }

  901.           return hash;

  902.         }

  903. 

  904.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  905.         public override string ToString() {

  906.           return pb::JsonFormatter.ToDiagnosticString(this);

  907.         }

  908. 

  909.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  910.         public void WriteTo(pb::CodedOutputStream output) {

  911.           virtualDevices_.WriteTo(output, _repeated_virtualDevices_codec);

  912.           if (UseUnifiedMemory != false) {

  913.             output.WriteRawTag(16);

  914.             output.WriteBool(UseUnifiedMemory);

  915.           }

  916.           if (NumDevToDevCopyStreams != 0) {

  917.             output.WriteRawTag(24);

  918.             output.WriteInt32(NumDevToDevCopyStreams);

  919.           }

  920.           if (CollectiveRingOrder.Length != 0) {

  921.             output.WriteRawTag(34);

  922.             output.WriteString(CollectiveRingOrder);

  923.           }

  924.           if (TimestampedAllocator != false) {

  925.             output.WriteRawTag(40);

  926.             output.WriteBool(TimestampedAllocator);

  927.           }

  928.           if (KernelTrackerMaxInterval != 0) {

  929.             output.WriteRawTag(56);

  930.             output.WriteInt32(KernelTrackerMaxInterval);

  931.           }

  932.           if (KernelTrackerMaxBytes != 0) {

  933.             output.WriteRawTag(64);

  934.             output.WriteInt32(KernelTrackerMaxBytes);

  935.           }

  936.           if (KernelTrackerMaxPending != 0) {

  937.             output.WriteRawTag(72);

  938.             output.WriteInt32(KernelTrackerMaxPending);

  939.           }

  940.           if (InternalFragmentationFraction != 0D) {

  941.             output.WriteRawTag(81);

  942.             output.WriteDouble(InternalFragmentationFraction);

  943.           }

  944.           if (UseCudaMallocAsync != false) {

  945.             output.WriteRawTag(88);

  946.             output.WriteBool(UseCudaMallocAsync);

  947.           }

  948.           if (_unknownFields != null) {

  949.             _unknownFields.WriteTo(output);

  950.           }

  951.         }

  952. 

  953.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  954.         public int CalculateSize() {

  955.           int size = 0;

  956.           size += virtualDevices_.CalculateSize(_repeated_virtualDevices_codec);

  957.           if (UseUnifiedMemory != false) {

  958.             size += 1 + 1;

  959.           }

  960.           if (NumDevToDevCopyStreams != 0) {

  961.             size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumDevToDevCopyStreams);

  962.           }

  963.           if (CollectiveRingOrder.Length != 0) {

  964.             size += 1 + pb::CodedOutputStream.ComputeStringSize(CollectiveRingOrder);

  965.           }

  966.           if (TimestampedAllocator != false) {

  967.             size += 1 + 1;

  968.           }

  969.           if (KernelTrackerMaxInterval != 0) {

  970.             size += 1 + pb::CodedOutputStream.ComputeInt32Size(KernelTrackerMaxInterval);

  971.           }

  972.           if (KernelTrackerMaxBytes != 0) {

  973.             size += 1 + pb::CodedOutputStream.ComputeInt32Size(KernelTrackerMaxBytes);

  974.           }

  975.           if (KernelTrackerMaxPending != 0) {

  976.             size += 1 + pb::CodedOutputStream.ComputeInt32Size(KernelTrackerMaxPending);

  977.           }

  978.           if (InternalFragmentationFraction != 0D) {

  979.             size += 1 + 8;

  980.           }

  981.           if (UseCudaMallocAsync != false) {

  982.             size += 1 + 1;

  983.           }

  984.           if (_unknownFields != null) {

  985.             size += _unknownFields.CalculateSize();

  986.           }

  987.           return size;

  988.         }

  989. 

  990.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  991.         public void MergeFrom(Experimental other) {

  992.           if (other == null) {

  993.             return;

  994.           }

  995.           virtualDevices_.Add(other.virtualDevices_);

  996.           if (other.UseUnifiedMemory != false) {

  997.             UseUnifiedMemory = other.UseUnifiedMemory;

  998.           }

  999.           if (other.NumDevToDevCopyStreams != 0) {

  1000.             NumDevToDevCopyStreams = other.NumDevToDevCopyStreams;

  1001.           }

  1002.           if (other.CollectiveRingOrder.Length != 0) {

  1003.             CollectiveRingOrder = other.CollectiveRingOrder;

  1004.           }

  1005.           if (other.TimestampedAllocator != false) {

  1006.             TimestampedAllocator = other.TimestampedAllocator;

  1007.           }

  1008.           if (other.KernelTrackerMaxInterval != 0) {

  1009.             KernelTrackerMaxInterval = other.KernelTrackerMaxInterval;

  1010.           }

  1011.           if (other.KernelTrackerMaxBytes != 0) {

  1012.             KernelTrackerMaxBytes = other.KernelTrackerMaxBytes;

  1013.           }

  1014.           if (other.KernelTrackerMaxPending != 0) {

  1015.             KernelTrackerMaxPending = other.KernelTrackerMaxPending;

  1016.           }

  1017.           if (other.InternalFragmentationFraction != 0D) {

  1018.             InternalFragmentationFraction = other.InternalFragmentationFraction;

  1019.           }

  1020.           if (other.UseCudaMallocAsync != false) {

  1021.             UseCudaMallocAsync = other.UseCudaMallocAsync;

  1022.           }

  1023.           _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1024.         }

  1025. 

  1026.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1027.         public void MergeFrom(pb::CodedInputStream input) {

  1028.           uint tag;

  1029.           while ((tag = input.ReadTag()) != 0) {

  1030.             switch(tag) {

  1031.               default:

  1032.                 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1033.                 break;

  1034.               case 10: {

  1035.                 virtualDevices_.AddEntriesFrom(input, _repeated_virtualDevices_codec);

  1036.                 break;

  1037.               }

  1038.               case 16: {

  1039.                 UseUnifiedMemory = input.ReadBool();

  1040.                 break;

  1041.               }

  1042.               case 24: {

  1043.                 NumDevToDevCopyStreams = input.ReadInt32();

  1044.                 break;

  1045.               }

  1046.               case 34: {

  1047.                 CollectiveRingOrder = input.ReadString();

  1048.                 break;

  1049.               }

  1050.               case 40: {

  1051.                 TimestampedAllocator = input.ReadBool();

  1052.                 break;

  1053.               }

  1054.               case 56: {

  1055.                 KernelTrackerMaxInterval = input.ReadInt32();

  1056.                 break;

  1057.               }

  1058.               case 64: {

  1059.                 KernelTrackerMaxBytes = input.ReadInt32();

  1060.                 break;

  1061.               }

  1062.               case 72: {

  1063.                 KernelTrackerMaxPending = input.ReadInt32();

  1064.                 break;

  1065.               }

  1066.               case 81: {

  1067.                 InternalFragmentationFraction = input.ReadDouble();

  1068.                 break;

  1069.               }

  1070.               case 88: {

  1071.                 UseCudaMallocAsync = input.ReadBool();

  1072.                 break;

  1073.               }

  1074.             }

  1075.           }

  1076.         }

  1077. 

  1078.         #region Nested types

  1079.         /// <summary>Container for nested types declared in the Experimental message type.</summary>

  1080.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1081.         public static partial class Types {

  1082.           /// <summary>

  1083.           /// Configuration for breaking down a visible GPU into multiple "virtual"

  1084.           /// devices.

  1085.           /// </summary>

  1086.           public sealed partial class VirtualDevices : pb::IMessage<VirtualDevices> {

  1087.             private static readonly pb::MessageParser<VirtualDevices> _parser = new pb::MessageParser<VirtualDevices>(() => new VirtualDevices());

  1088.             private pb::UnknownFieldSet _unknownFields;

  1089.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1090.             public static pb::MessageParser<VirtualDevices> Parser { get { return _parser; } }

  1091. 

  1092.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1093.             public static pbr::MessageDescriptor Descriptor {

  1094.               get { return global::Tensorflow.GPUOptions.Types.Experimental.Descriptor.NestedTypes[0]; }

  1095.             }

  1096. 

  1097.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1098.             pbr::MessageDescriptor pb::IMessage.Descriptor {

  1099.               get { return Descriptor; }

  1100.             }

  1101. 

  1102.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1103.             public VirtualDevices() {

  1104.               OnConstruction();

  1105.             }

  1106. 

  1107.             partial void OnConstruction();

  1108. 

  1109.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1110.             public VirtualDevices(VirtualDevices other) : this() {

  1111.               memoryLimitMb_ = other.memoryLimitMb_.Clone();

  1112.               priority_ = other.priority_.Clone();

  1113.               _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  1114.             }

  1115. 

  1116.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1117.             public VirtualDevices Clone() {

  1118.               return new VirtualDevices(this);

  1119.             }

  1120. 

  1121.             /// <summary>Field number for the "memory_limit_mb" field.</summary>

  1122.             public const int MemoryLimitMbFieldNumber = 1;

  1123.             private static readonly pb::FieldCodec<float> _repeated_memoryLimitMb_codec

  1124.                 = pb::FieldCodec.ForFloat(10);

  1125.             private readonly pbc::RepeatedField<float> memoryLimitMb_ = new pbc::RepeatedField<float>();

  1126.             /// <summary>

  1127.             /// Per "virtual" device memory limit, in MB. The number of elements in

  1128.             /// the list is the number of virtual devices to create on the

  1129.             /// corresponding visible GPU (see "virtual_devices" below).

  1130.             /// If empty, it will create single virtual device taking all available

  1131.             /// memory from the device.

  1132.             ///

  1133.             /// For the concept of "visible" and "virtual" GPU, see the comments for

  1134.             /// "visible_device_list" above for more information.

  1135.             /// </summary>

  1136.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1137.             public pbc::RepeatedField<float> MemoryLimitMb {

  1138.               get { return memoryLimitMb_; }

  1139.             }

  1140. 

  1141.             /// <summary>Field number for the "priority" field.</summary>

  1142.             public const int PriorityFieldNumber = 2;

  1143.             private static readonly pb::FieldCodec<int> _repeated_priority_codec

  1144.                 = pb::FieldCodec.ForInt32(18);

  1145.             private readonly pbc::RepeatedField<int> priority_ = new pbc::RepeatedField<int>();

  1146.             /// <summary>

  1147.             /// Priority values to use with the virtual devices. Use the cuda function

  1148.             /// cudaDeviceGetStreamPriorityRange to query for valid range of values for

  1149.             /// priority.

  1150.             ///

  1151.             /// On a P4000 GPU with cuda 10.1, the priority range reported was 0 for

  1152.             /// least priority and -1 for greatest priority.

  1153.             ///

  1154.             /// If this field is not specified, then the virtual devices will be

  1155.             /// created with the default. If this field has values set, then the size

  1156.             /// of this must match with the above memory_limit_mb.

  1157.             /// </summary>

  1158.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1159.             public pbc::RepeatedField<int> Priority {

  1160.               get { return priority_; }

  1161.             }

  1162. 

  1163.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1164.             public override bool Equals(object other) {

  1165.               return Equals(other as VirtualDevices);

  1166.             }

  1167. 

  1168.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1169.             public bool Equals(VirtualDevices other) {

  1170.               if (ReferenceEquals(other, null)) {

  1171.                 return false;

  1172.               }

  1173.               if (ReferenceEquals(other, this)) {

  1174.                 return true;

  1175.               }

  1176.               if(!memoryLimitMb_.Equals(other.memoryLimitMb_)) return false;

  1177.               if(!priority_.Equals(other.priority_)) return false;

  1178.               return Equals(_unknownFields, other._unknownFields);

  1179.             }

  1180. 

  1181.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1182.             public override int GetHashCode() {

  1183.               int hash = 1;

  1184.               hash ^= memoryLimitMb_.GetHashCode();

  1185.               hash ^= priority_.GetHashCode();

  1186.               if (_unknownFields != null) {

  1187.                 hash ^= _unknownFields.GetHashCode();

  1188.               }

  1189.               return hash;

  1190.             }

  1191. 

  1192.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1193.             public override string ToString() {

  1194.               return pb::JsonFormatter.ToDiagnosticString(this);

  1195.             }

  1196. 

  1197.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1198.             public void WriteTo(pb::CodedOutputStream output) {

  1199.               memoryLimitMb_.WriteTo(output, _repeated_memoryLimitMb_codec);

  1200.               priority_.WriteTo(output, _repeated_priority_codec);

  1201.               if (_unknownFields != null) {

  1202.                 _unknownFields.WriteTo(output);

  1203.               }

  1204.             }

  1205. 

  1206.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1207.             public int CalculateSize() {

  1208.               int size = 0;

  1209.               size += memoryLimitMb_.CalculateSize(_repeated_memoryLimitMb_codec);

  1210.               size += priority_.CalculateSize(_repeated_priority_codec);

  1211.               if (_unknownFields != null) {

  1212.                 size += _unknownFields.CalculateSize();

  1213.               }

  1214.               return size;

  1215.             }

  1216. 

  1217.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1218.             public void MergeFrom(VirtualDevices other) {

  1219.               if (other == null) {

  1220.                 return;

  1221.               }

  1222.               memoryLimitMb_.Add(other.memoryLimitMb_);

  1223.               priority_.Add(other.priority_);

  1224.               _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1225.             }

  1226. 

  1227.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1228.             public void MergeFrom(pb::CodedInputStream input) {

  1229.               uint tag;

  1230.               while ((tag = input.ReadTag()) != 0) {

  1231.                 switch(tag) {

  1232.                   default:

  1233.                     _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1234.                     break;

  1235.                   case 10:

  1236.                   case 13: {

  1237.                     memoryLimitMb_.AddEntriesFrom(input, _repeated_memoryLimitMb_codec);

  1238.                     break;

  1239.                   }

  1240.                   case 18:

  1241.                   case 16: {

  1242.                     priority_.AddEntriesFrom(input, _repeated_priority_codec);

  1243.                     break;

  1244.                   }

  1245.                 }

  1246.               }

  1247.             }

  1248. 

  1249.           }

  1250. 

  1251.         }

  1252.         #endregion

  1253. 

  1254.       }

  1255. 

  1256.     }

  1257.     #endregion

  1258. 

  1259.   }

  1260. 

  1261.   /// <summary>

  1262.   /// Options passed to the graph optimizer

  1263.   /// </summary>

  1264.   public sealed partial class OptimizerOptions : pb::IMessage<OptimizerOptions> {

  1265.     private static readonly pb::MessageParser<OptimizerOptions> _parser = new pb::MessageParser<OptimizerOptions>(() => new OptimizerOptions());

  1266.     private pb::UnknownFieldSet _unknownFields;

  1267.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1268.     public static pb::MessageParser<OptimizerOptions> Parser { get { return _parser; } }

  1269. 

  1270.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1271.     public static pbr::MessageDescriptor Descriptor {

  1272.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[1]; }

  1273.     }

  1274. 

  1275.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1276.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1277.       get { return Descriptor; }

  1278.     }

  1279. 

  1280.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1281.     public OptimizerOptions() {

  1282.       OnConstruction();

  1283.     }

  1284. 

  1285.     partial void OnConstruction();

  1286. 

  1287.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1288.     public OptimizerOptions(OptimizerOptions other) : this() {

  1289.       doCommonSubexpressionElimination_ = other.doCommonSubexpressionElimination_;

  1290.       doConstantFolding_ = other.doConstantFolding_;

  1291.       maxFoldedConstantInBytes_ = other.maxFoldedConstantInBytes_;

  1292.       doFunctionInlining_ = other.doFunctionInlining_;

  1293.       optLevel_ = other.optLevel_;

  1294.       globalJitLevel_ = other.globalJitLevel_;

  1295.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  1296.     }

  1297. 

  1298.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1299.     public OptimizerOptions Clone() {

  1300.       return new OptimizerOptions(this);

  1301.     }

  1302. 

  1303.     /// <summary>Field number for the "do_common_subexpression_elimination" field.</summary>

  1304.     public const int DoCommonSubexpressionEliminationFieldNumber = 1;

  1305.     private bool doCommonSubexpressionElimination_;

  1306.     /// <summary>

  1307.     /// If true, optimize the graph using common subexpression elimination.

  1308.     /// Note: the optimization Level L1 will override this setting to true. So in

  1309.     /// order to disable common subexpression elimination the opt_level has to be

  1310.     /// set to L0.

  1311.     /// </summary>

  1312.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1313.     public bool DoCommonSubexpressionElimination {

  1314.       get { return doCommonSubexpressionElimination_; }

  1315.       set {

  1316.         doCommonSubexpressionElimination_ = value;

  1317.       }

  1318.     }

  1319. 

  1320.     /// <summary>Field number for the "do_constant_folding" field.</summary>

  1321.     public const int DoConstantFoldingFieldNumber = 2;

  1322.     private bool doConstantFolding_;

  1323.     /// <summary>

  1324.     /// If true, perform constant folding optimization on the graph.

  1325.     /// Note: the optimization Level L1 will override this setting to true. So in

  1326.     /// order to disable constant folding the opt_level has to be set to L0.

  1327.     /// </summary>

  1328.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1329.     public bool DoConstantFolding {

  1330.       get { return doConstantFolding_; }

  1331.       set {

  1332.         doConstantFolding_ = value;

  1333.       }

  1334.     }

  1335. 

  1336.     /// <summary>Field number for the "max_folded_constant_in_bytes" field.</summary>

  1337.     public const int MaxFoldedConstantInBytesFieldNumber = 6;

  1338.     private long maxFoldedConstantInBytes_;

  1339.     /// <summary>

  1340.     /// Constant folding optimization replaces tensors whose values can be

  1341.     /// predetermined, with constant nodes. To avoid inserting too large constants,

  1342.     /// the size of each constant created can be limited. If this value is zero, a

  1343.     /// default limit of 10 MiB will be applied. If constant folding optimization

  1344.     /// is disabled, this value is ignored.

  1345.     /// </summary>

  1346.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1347.     public long MaxFoldedConstantInBytes {

  1348.       get { return maxFoldedConstantInBytes_; }

  1349.       set {

  1350.         maxFoldedConstantInBytes_ = value;

  1351.       }

  1352.     }

  1353. 

  1354.     /// <summary>Field number for the "do_function_inlining" field.</summary>

  1355.     public const int DoFunctionInliningFieldNumber = 4;

  1356.     private bool doFunctionInlining_;

  1357.     /// <summary>

  1358.     /// If true, perform function inlining on the graph.

  1359.     /// </summary>

  1360.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1361.     public bool DoFunctionInlining {

  1362.       get { return doFunctionInlining_; }

  1363.       set {

  1364.         doFunctionInlining_ = value;

  1365.       }

  1366.     }

  1367. 

  1368.     /// <summary>Field number for the "opt_level" field.</summary>

  1369.     public const int OptLevelFieldNumber = 3;

  1370.     private global::Tensorflow.OptimizerOptions.Types.Level optLevel_ = global::Tensorflow.OptimizerOptions.Types.Level.L1;

  1371.     /// <summary>

  1372.     /// Overall optimization level. The actual optimizations applied will be the

  1373.     /// logical OR of the flags that this level implies and any flags already set.

  1374.     /// </summary>

  1375.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1376.     public global::Tensorflow.OptimizerOptions.Types.Level OptLevel {

  1377.       get { return optLevel_; }

  1378.       set {

  1379.         optLevel_ = value;

  1380.       }

  1381.     }

  1382. 

  1383.     /// <summary>Field number for the "global_jit_level" field.</summary>

  1384.     public const int GlobalJitLevelFieldNumber = 5;

  1385.     private global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel globalJitLevel_ = global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel.Default;

  1386.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1387.     public global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel GlobalJitLevel {

  1388.       get { return globalJitLevel_; }

  1389.       set {

  1390.         globalJitLevel_ = value;

  1391.       }

  1392.     }

  1393. 

  1394.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1395.     public override bool Equals(object other) {

  1396.       return Equals(other as OptimizerOptions);

  1397.     }

  1398. 

  1399.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1400.     public bool Equals(OptimizerOptions other) {

  1401.       if (ReferenceEquals(other, null)) {

  1402.         return false;

  1403.       }

  1404.       if (ReferenceEquals(other, this)) {

  1405.         return true;

  1406.       }

  1407.       if (DoCommonSubexpressionElimination != other.DoCommonSubexpressionElimination) return false;

  1408.       if (DoConstantFolding != other.DoConstantFolding) return false;

  1409.       if (MaxFoldedConstantInBytes != other.MaxFoldedConstantInBytes) return false;

  1410.       if (DoFunctionInlining != other.DoFunctionInlining) return false;

  1411.       if (OptLevel != other.OptLevel) return false;

  1412.       if (GlobalJitLevel != other.GlobalJitLevel) return false;

  1413.       return Equals(_unknownFields, other._unknownFields);

  1414.     }

  1415. 

  1416.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1417.     public override int GetHashCode() {

  1418.       int hash = 1;

  1419.       if (DoCommonSubexpressionElimination != false) hash ^= DoCommonSubexpressionElimination.GetHashCode();

  1420.       if (DoConstantFolding != false) hash ^= DoConstantFolding.GetHashCode();

  1421.       if (MaxFoldedConstantInBytes != 0L) hash ^= MaxFoldedConstantInBytes.GetHashCode();

  1422.       if (DoFunctionInlining != false) hash ^= DoFunctionInlining.GetHashCode();

  1423.       if (OptLevel != global::Tensorflow.OptimizerOptions.Types.Level.L1) hash ^= OptLevel.GetHashCode();

  1424.       if (GlobalJitLevel != global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel.Default) hash ^= GlobalJitLevel.GetHashCode();

  1425.       if (_unknownFields != null) {

  1426.         hash ^= _unknownFields.GetHashCode();

  1427.       }

  1428.       return hash;

  1429.     }

  1430. 

  1431.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1432.     public override string ToString() {

  1433.       return pb::JsonFormatter.ToDiagnosticString(this);

  1434.     }

  1435. 

  1436.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1437.     public void WriteTo(pb::CodedOutputStream output) {

  1438.       if (DoCommonSubexpressionElimination != false) {

  1439.         output.WriteRawTag(8);

  1440.         output.WriteBool(DoCommonSubexpressionElimination);

  1441.       }

  1442.       if (DoConstantFolding != false) {

  1443.         output.WriteRawTag(16);

  1444.         output.WriteBool(DoConstantFolding);

  1445.       }

  1446.       if (OptLevel != global::Tensorflow.OptimizerOptions.Types.Level.L1) {

  1447.         output.WriteRawTag(24);

  1448.         output.WriteEnum((int) OptLevel);

  1449.       }

  1450.       if (DoFunctionInlining != false) {

  1451.         output.WriteRawTag(32);

  1452.         output.WriteBool(DoFunctionInlining);

  1453.       }

  1454.       if (GlobalJitLevel != global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel.Default) {

  1455.         output.WriteRawTag(40);

  1456.         output.WriteEnum((int) GlobalJitLevel);

  1457.       }

  1458.       if (MaxFoldedConstantInBytes != 0L) {

  1459.         output.WriteRawTag(48);

  1460.         output.WriteInt64(MaxFoldedConstantInBytes);

  1461.       }

  1462.       if (_unknownFields != null) {

  1463.         _unknownFields.WriteTo(output);

  1464.       }

  1465.     }

  1466. 

  1467.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1468.     public int CalculateSize() {

  1469.       int size = 0;

  1470.       if (DoCommonSubexpressionElimination != false) {

  1471.         size += 1 + 1;

  1472.       }

  1473.       if (DoConstantFolding != false) {

  1474.         size += 1 + 1;

  1475.       }

  1476.       if (MaxFoldedConstantInBytes != 0L) {

  1477.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(MaxFoldedConstantInBytes);

  1478.       }

  1479.       if (DoFunctionInlining != false) {

  1480.         size += 1 + 1;

  1481.       }

  1482.       if (OptLevel != global::Tensorflow.OptimizerOptions.Types.Level.L1) {

  1483.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OptLevel);

  1484.       }

  1485.       if (GlobalJitLevel != global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel.Default) {

  1486.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) GlobalJitLevel);

  1487.       }

  1488.       if (_unknownFields != null) {

  1489.         size += _unknownFields.CalculateSize();

  1490.       }

  1491.       return size;

  1492.     }

  1493. 

  1494.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1495.     public void MergeFrom(OptimizerOptions other) {

  1496.       if (other == null) {

  1497.         return;

  1498.       }

  1499.       if (other.DoCommonSubexpressionElimination != false) {

  1500.         DoCommonSubexpressionElimination = other.DoCommonSubexpressionElimination;

  1501.       }

  1502.       if (other.DoConstantFolding != false) {

  1503.         DoConstantFolding = other.DoConstantFolding;

  1504.       }

  1505.       if (other.MaxFoldedConstantInBytes != 0L) {

  1506.         MaxFoldedConstantInBytes = other.MaxFoldedConstantInBytes;

  1507.       }

  1508.       if (other.DoFunctionInlining != false) {

  1509.         DoFunctionInlining = other.DoFunctionInlining;

  1510.       }

  1511.       if (other.OptLevel != global::Tensorflow.OptimizerOptions.Types.Level.L1) {

  1512.         OptLevel = other.OptLevel;

  1513.       }

  1514.       if (other.GlobalJitLevel != global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel.Default) {

  1515.         GlobalJitLevel = other.GlobalJitLevel;

  1516.       }

  1517.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1518.     }

  1519. 

  1520.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1521.     public void MergeFrom(pb::CodedInputStream input) {

  1522.       uint tag;

  1523.       while ((tag = input.ReadTag()) != 0) {

  1524.         switch(tag) {

  1525.           default:

  1526.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1527.             break;

  1528.           case 8: {

  1529.             DoCommonSubexpressionElimination = input.ReadBool();

  1530.             break;

  1531.           }

  1532.           case 16: {

  1533.             DoConstantFolding = input.ReadBool();

  1534.             break;

  1535.           }

  1536.           case 24: {

  1537.             OptLevel = (global::Tensorflow.OptimizerOptions.Types.Level) input.ReadEnum();

  1538.             break;

  1539.           }

  1540.           case 32: {

  1541.             DoFunctionInlining = input.ReadBool();

  1542.             break;

  1543.           }

  1544.           case 40: {

  1545.             GlobalJitLevel = (global::Tensorflow.OptimizerOptions.Types.GlobalJitLevel) input.ReadEnum();

  1546.             break;

  1547.           }

  1548.           case 48: {

  1549.             MaxFoldedConstantInBytes = input.ReadInt64();

  1550.             break;

  1551.           }

  1552.         }

  1553.       }

  1554.     }

  1555. 

  1556.     #region Nested types

  1557.     /// <summary>Container for nested types declared in the OptimizerOptions message type.</summary>

  1558.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1559.     public static partial class Types {

  1560.       /// <summary>

  1561.       /// Optimization level

  1562.       /// </summary>

  1563.       public enum Level {

  1564.         /// <summary>

  1565.         /// L1 is the default level.

  1566.         /// Optimization performed at L1 :

  1567.         /// 1. Common subexpression elimination

  1568.         /// 2. Constant folding

  1569.         /// </summary>

  1570.         [pbr::OriginalName("L1")] L1 = 0,

  1571.         /// <summary>

  1572.         /// No optimizations

  1573.         /// </summary>

  1574.         [pbr::OriginalName("L0")] L0 = -1,

  1575.       }

  1576. 

  1577.       /// <summary>

  1578.       /// Control the use of the compiler/jit.  Experimental.

  1579.       /// </summary>

  1580.       public enum GlobalJitLevel {

  1581.         /// <summary>

  1582.         /// Default setting ("off" now, but later expected to be "on")

  1583.         /// </summary>

  1584.         [pbr::OriginalName("DEFAULT")] Default = 0,

  1585.         [pbr::OriginalName("OFF")] Off = -1,

  1586.         /// <summary>

  1587.         /// The following settings turn on compilation, with higher values being

  1588.         /// more aggressive.  Higher values may reduce opportunities for parallelism

  1589.         /// and may use more memory.  (At present, there is no distinction, but this

  1590.         /// is expected to change.)

  1591.         /// </summary>

  1592.         [pbr::OriginalName("ON_1")] On1 = 1,

  1593.         [pbr::OriginalName("ON_2")] On2 = 2,

  1594.       }

  1595. 

  1596.     }

  1597.     #endregion

  1598. 

  1599.   }

  1600. 

  1601.   public sealed partial class GraphOptions : pb::IMessage<GraphOptions> {

  1602.     private static readonly pb::MessageParser<GraphOptions> _parser = new pb::MessageParser<GraphOptions>(() => new GraphOptions());

  1603.     private pb::UnknownFieldSet _unknownFields;

  1604.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1605.     public static pb::MessageParser<GraphOptions> Parser { get { return _parser; } }

  1606. 

  1607.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1608.     public static pbr::MessageDescriptor Descriptor {

  1609.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[2]; }

  1610.     }

  1611. 

  1612.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1613.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  1614.       get { return Descriptor; }

  1615.     }

  1616. 

  1617.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1618.     public GraphOptions() {

  1619.       OnConstruction();

  1620.     }

  1621. 

  1622.     partial void OnConstruction();

  1623. 

  1624.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1625.     public GraphOptions(GraphOptions other) : this() {

  1626.       enableRecvScheduling_ = other.enableRecvScheduling_;

  1627.       optimizerOptions_ = other.optimizerOptions_ != null ? other.optimizerOptions_.Clone() : null;

  1628.       buildCostModel_ = other.buildCostModel_;

  1629.       buildCostModelAfter_ = other.buildCostModelAfter_;

  1630.       inferShapes_ = other.inferShapes_;

  1631.       placePrunedGraph_ = other.placePrunedGraph_;

  1632.       enableBfloat16Sendrecv_ = other.enableBfloat16Sendrecv_;

  1633.       timelineStep_ = other.timelineStep_;

  1634.       rewriteOptions_ = other.rewriteOptions_ != null ? other.rewriteOptions_.Clone() : null;

  1635.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  1636.     }

  1637. 

  1638.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1639.     public GraphOptions Clone() {

  1640.       return new GraphOptions(this);

  1641.     }

  1642. 

  1643.     /// <summary>Field number for the "enable_recv_scheduling" field.</summary>

  1644.     public const int EnableRecvSchedulingFieldNumber = 2;

  1645.     private bool enableRecvScheduling_;

  1646.     /// <summary>

  1647.     /// If true, use control flow to schedule the activation of Recv nodes.

  1648.     /// (Currently ignored.)

  1649.     /// </summary>

  1650.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1651.     public bool EnableRecvScheduling {

  1652.       get { return enableRecvScheduling_; }

  1653.       set {

  1654.         enableRecvScheduling_ = value;

  1655.       }

  1656.     }

  1657. 

  1658.     /// <summary>Field number for the "optimizer_options" field.</summary>

  1659.     public const int OptimizerOptionsFieldNumber = 3;

  1660.     private global::Tensorflow.OptimizerOptions optimizerOptions_;

  1661.     /// <summary>

  1662.     /// Options controlling how graph is optimized.

  1663.     /// </summary>

  1664.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1665.     public global::Tensorflow.OptimizerOptions OptimizerOptions {

  1666.       get { return optimizerOptions_; }

  1667.       set {

  1668.         optimizerOptions_ = value;

  1669.       }

  1670.     }

  1671. 

  1672.     /// <summary>Field number for the "build_cost_model" field.</summary>

  1673.     public const int BuildCostModelFieldNumber = 4;

  1674.     private long buildCostModel_;

  1675.     /// <summary>

  1676.     /// The number of steps to run before returning a cost model detailing

  1677.     /// the memory usage and performance of each node of the graph. 0 means

  1678.     /// no cost model.

  1679.     /// </summary>

  1680.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1681.     public long BuildCostModel {

  1682.       get { return buildCostModel_; }

  1683.       set {

  1684.         buildCostModel_ = value;

  1685.       }

  1686.     }

  1687. 

  1688.     /// <summary>Field number for the "build_cost_model_after" field.</summary>

  1689.     public const int BuildCostModelAfterFieldNumber = 9;

  1690.     private long buildCostModelAfter_;

  1691.     /// <summary>

  1692.     /// The number of steps to skip before collecting statistics for the

  1693.     /// cost model.

  1694.     /// </summary>

  1695.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1696.     public long BuildCostModelAfter {

  1697.       get { return buildCostModelAfter_; }

  1698.       set {

  1699.         buildCostModelAfter_ = value;

  1700.       }

  1701.     }

  1702. 

  1703.     /// <summary>Field number for the "infer_shapes" field.</summary>

  1704.     public const int InferShapesFieldNumber = 5;

  1705.     private bool inferShapes_;

  1706.     /// <summary>

  1707.     /// Annotate each Node with Op output shape data, to the extent it can

  1708.     /// be statically inferred.

  1709.     /// </summary>

  1710.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1711.     public bool InferShapes {

  1712.       get { return inferShapes_; }

  1713.       set {

  1714.         inferShapes_ = value;

  1715.       }

  1716.     }

  1717. 

  1718.     /// <summary>Field number for the "place_pruned_graph" field.</summary>

  1719.     public const int PlacePrunedGraphFieldNumber = 6;

  1720.     private bool placePrunedGraph_;

  1721.     /// <summary>

  1722.     /// Only place the subgraphs that are run, rather than the entire graph.

  1723.     ///

  1724.     /// This is useful for interactive graph building, where one might

  1725.     /// produce graphs that cannot be placed during the debugging

  1726.     /// process.  In particular, it allows the client to continue work in

  1727.     /// a session after adding a node to a graph whose placement

  1728.     /// constraints are unsatisfiable.

  1729.     /// </summary>

  1730.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1731.     public bool PlacePrunedGraph {

  1732.       get { return placePrunedGraph_; }

  1733.       set {

  1734.         placePrunedGraph_ = value;

  1735.       }

  1736.     }

  1737. 

  1738.     /// <summary>Field number for the "enable_bfloat16_sendrecv" field.</summary>

  1739.     public const int EnableBfloat16SendrecvFieldNumber = 7;

  1740.     private bool enableBfloat16Sendrecv_;

  1741.     /// <summary>

  1742.     /// If true, transfer float values between processes as bfloat16.

  1743.     /// </summary>

  1744.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1745.     public bool EnableBfloat16Sendrecv {

  1746.       get { return enableBfloat16Sendrecv_; }

  1747.       set {

  1748.         enableBfloat16Sendrecv_ = value;

  1749.       }

  1750.     }

  1751. 

  1752.     /// <summary>Field number for the "timeline_step" field.</summary>

  1753.     public const int TimelineStepFieldNumber = 8;

  1754.     private int timelineStep_;

  1755.     /// <summary>

  1756.     /// If > 0, record a timeline every this many steps.

  1757.     /// EXPERIMENTAL: This currently has no effect in MasterSession.

  1758.     /// </summary>

  1759.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1760.     public int TimelineStep {

  1761.       get { return timelineStep_; }

  1762.       set {

  1763.         timelineStep_ = value;

  1764.       }

  1765.     }

  1766. 

  1767.     /// <summary>Field number for the "rewrite_options" field.</summary>

  1768.     public const int RewriteOptionsFieldNumber = 10;

  1769.     private global::Tensorflow.RewriterConfig rewriteOptions_;

  1770.     /// <summary>

  1771.     /// Options that control the type and amount of graph rewriting.

  1772.     /// Not currently configurable via the public Python API (i.e. there is no API

  1773.     /// stability guarantee if you import RewriterConfig explicitly).

  1774.     /// </summary>

  1775.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1776.     public global::Tensorflow.RewriterConfig RewriteOptions {

  1777.       get { return rewriteOptions_; }

  1778.       set {

  1779.         rewriteOptions_ = value;

  1780.       }

  1781.     }

  1782. 

  1783.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1784.     public override bool Equals(object other) {

  1785.       return Equals(other as GraphOptions);

  1786.     }

  1787. 

  1788.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1789.     public bool Equals(GraphOptions other) {

  1790.       if (ReferenceEquals(other, null)) {

  1791.         return false;

  1792.       }

  1793.       if (ReferenceEquals(other, this)) {

  1794.         return true;

  1795.       }

  1796.       if (EnableRecvScheduling != other.EnableRecvScheduling) return false;

  1797.       if (!object.Equals(OptimizerOptions, other.OptimizerOptions)) return false;

  1798.       if (BuildCostModel != other.BuildCostModel) return false;

  1799.       if (BuildCostModelAfter != other.BuildCostModelAfter) return false;

  1800.       if (InferShapes != other.InferShapes) return false;

  1801.       if (PlacePrunedGraph != other.PlacePrunedGraph) return false;

  1802.       if (EnableBfloat16Sendrecv != other.EnableBfloat16Sendrecv) return false;

  1803.       if (TimelineStep != other.TimelineStep) return false;

  1804.       if (!object.Equals(RewriteOptions, other.RewriteOptions)) return false;

  1805.       return Equals(_unknownFields, other._unknownFields);

  1806.     }

  1807. 

  1808.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1809.     public override int GetHashCode() {

  1810.       int hash = 1;

  1811.       if (EnableRecvScheduling != false) hash ^= EnableRecvScheduling.GetHashCode();

  1812.       if (optimizerOptions_ != null) hash ^= OptimizerOptions.GetHashCode();

  1813.       if (BuildCostModel != 0L) hash ^= BuildCostModel.GetHashCode();

  1814.       if (BuildCostModelAfter != 0L) hash ^= BuildCostModelAfter.GetHashCode();

  1815.       if (InferShapes != false) hash ^= InferShapes.GetHashCode();

  1816.       if (PlacePrunedGraph != false) hash ^= PlacePrunedGraph.GetHashCode();

  1817.       if (EnableBfloat16Sendrecv != false) hash ^= EnableBfloat16Sendrecv.GetHashCode();

  1818.       if (TimelineStep != 0) hash ^= TimelineStep.GetHashCode();

  1819.       if (rewriteOptions_ != null) hash ^= RewriteOptions.GetHashCode();

  1820.       if (_unknownFields != null) {

  1821.         hash ^= _unknownFields.GetHashCode();

  1822.       }

  1823.       return hash;

  1824.     }

  1825. 

  1826.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1827.     public override string ToString() {

  1828.       return pb::JsonFormatter.ToDiagnosticString(this);

  1829.     }

  1830. 

  1831.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1832.     public void WriteTo(pb::CodedOutputStream output) {

  1833.       if (EnableRecvScheduling != false) {

  1834.         output.WriteRawTag(16);

  1835.         output.WriteBool(EnableRecvScheduling);

  1836.       }

  1837.       if (optimizerOptions_ != null) {

  1838.         output.WriteRawTag(26);

  1839.         output.WriteMessage(OptimizerOptions);

  1840.       }

  1841.       if (BuildCostModel != 0L) {

  1842.         output.WriteRawTag(32);

  1843.         output.WriteInt64(BuildCostModel);

  1844.       }

  1845.       if (InferShapes != false) {

  1846.         output.WriteRawTag(40);

  1847.         output.WriteBool(InferShapes);

  1848.       }

  1849.       if (PlacePrunedGraph != false) {

  1850.         output.WriteRawTag(48);

  1851.         output.WriteBool(PlacePrunedGraph);

  1852.       }

  1853.       if (EnableBfloat16Sendrecv != false) {

  1854.         output.WriteRawTag(56);

  1855.         output.WriteBool(EnableBfloat16Sendrecv);

  1856.       }

  1857.       if (TimelineStep != 0) {

  1858.         output.WriteRawTag(64);

  1859.         output.WriteInt32(TimelineStep);

  1860.       }

  1861.       if (BuildCostModelAfter != 0L) {

  1862.         output.WriteRawTag(72);

  1863.         output.WriteInt64(BuildCostModelAfter);

  1864.       }

  1865.       if (rewriteOptions_ != null) {

  1866.         output.WriteRawTag(82);

  1867.         output.WriteMessage(RewriteOptions);

  1868.       }

  1869.       if (_unknownFields != null) {

  1870.         _unknownFields.WriteTo(output);

  1871.       }

  1872.     }

  1873. 

  1874.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1875.     public int CalculateSize() {

  1876.       int size = 0;

  1877.       if (EnableRecvScheduling != false) {

  1878.         size += 1 + 1;

  1879.       }

  1880.       if (optimizerOptions_ != null) {

  1881.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(OptimizerOptions);

  1882.       }

  1883.       if (BuildCostModel != 0L) {

  1884.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(BuildCostModel);

  1885.       }

  1886.       if (BuildCostModelAfter != 0L) {

  1887.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(BuildCostModelAfter);

  1888.       }

  1889.       if (InferShapes != false) {

  1890.         size += 1 + 1;

  1891.       }

  1892.       if (PlacePrunedGraph != false) {

  1893.         size += 1 + 1;

  1894.       }

  1895.       if (EnableBfloat16Sendrecv != false) {

  1896.         size += 1 + 1;

  1897.       }

  1898.       if (TimelineStep != 0) {

  1899.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(TimelineStep);

  1900.       }

  1901.       if (rewriteOptions_ != null) {

  1902.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(RewriteOptions);

  1903.       }

  1904.       if (_unknownFields != null) {

  1905.         size += _unknownFields.CalculateSize();

  1906.       }

  1907.       return size;

  1908.     }

  1909. 

  1910.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1911.     public void MergeFrom(GraphOptions other) {

  1912.       if (other == null) {

  1913.         return;

  1914.       }

  1915.       if (other.EnableRecvScheduling != false) {

  1916.         EnableRecvScheduling = other.EnableRecvScheduling;

  1917.       }

  1918.       if (other.optimizerOptions_ != null) {

  1919.         if (optimizerOptions_ == null) {

  1920.           OptimizerOptions = new global::Tensorflow.OptimizerOptions();

  1921.         }

  1922.         OptimizerOptions.MergeFrom(other.OptimizerOptions);

  1923.       }

  1924.       if (other.BuildCostModel != 0L) {

  1925.         BuildCostModel = other.BuildCostModel;

  1926.       }

  1927.       if (other.BuildCostModelAfter != 0L) {

  1928.         BuildCostModelAfter = other.BuildCostModelAfter;

  1929.       }

  1930.       if (other.InferShapes != false) {

  1931.         InferShapes = other.InferShapes;

  1932.       }

  1933.       if (other.PlacePrunedGraph != false) {

  1934.         PlacePrunedGraph = other.PlacePrunedGraph;

  1935.       }

  1936.       if (other.EnableBfloat16Sendrecv != false) {

  1937.         EnableBfloat16Sendrecv = other.EnableBfloat16Sendrecv;

  1938.       }

  1939.       if (other.TimelineStep != 0) {

  1940.         TimelineStep = other.TimelineStep;

  1941.       }

  1942.       if (other.rewriteOptions_ != null) {

  1943.         if (rewriteOptions_ == null) {

  1944.           RewriteOptions = new global::Tensorflow.RewriterConfig();

  1945.         }

  1946.         RewriteOptions.MergeFrom(other.RewriteOptions);

  1947.       }

  1948.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  1949.     }

  1950. 

  1951.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  1952.     public void MergeFrom(pb::CodedInputStream input) {

  1953.       uint tag;

  1954.       while ((tag = input.ReadTag()) != 0) {

  1955.         switch(tag) {

  1956.           default:

  1957.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  1958.             break;

  1959.           case 16: {

  1960.             EnableRecvScheduling = input.ReadBool();

  1961.             break;

  1962.           }

  1963.           case 26: {

  1964.             if (optimizerOptions_ == null) {

  1965.               OptimizerOptions = new global::Tensorflow.OptimizerOptions();

  1966.             }

  1967.             input.ReadMessage(OptimizerOptions);

  1968.             break;

  1969.           }

  1970.           case 32: {

  1971.             BuildCostModel = input.ReadInt64();

  1972.             break;

  1973.           }

  1974.           case 40: {

  1975.             InferShapes = input.ReadBool();

  1976.             break;

  1977.           }

  1978.           case 48: {

  1979.             PlacePrunedGraph = input.ReadBool();

  1980.             break;

  1981.           }

  1982.           case 56: {

  1983.             EnableBfloat16Sendrecv = input.ReadBool();

  1984.             break;

  1985.           }

  1986.           case 64: {

  1987.             TimelineStep = input.ReadInt32();

  1988.             break;

  1989.           }

  1990.           case 72: {

  1991.             BuildCostModelAfter = input.ReadInt64();

  1992.             break;

  1993.           }

  1994.           case 82: {

  1995.             if (rewriteOptions_ == null) {

  1996.               RewriteOptions = new global::Tensorflow.RewriterConfig();

  1997.             }

  1998.             input.ReadMessage(RewriteOptions);

  1999.             break;

  2000.           }

  2001.         }

  2002.       }

  2003.     }

  2004. 

  2005.   }

  2006. 

  2007.   public sealed partial class ThreadPoolOptionProto : pb::IMessage<ThreadPoolOptionProto> {

  2008.     private static readonly pb::MessageParser<ThreadPoolOptionProto> _parser = new pb::MessageParser<ThreadPoolOptionProto>(() => new ThreadPoolOptionProto());

  2009.     private pb::UnknownFieldSet _unknownFields;

  2010.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2011.     public static pb::MessageParser<ThreadPoolOptionProto> Parser { get { return _parser; } }

  2012. 

  2013.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2014.     public static pbr::MessageDescriptor Descriptor {

  2015.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[3]; }

  2016.     }

  2017. 

  2018.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2019.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  2020.       get { return Descriptor; }

  2021.     }

  2022. 

  2023.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2024.     public ThreadPoolOptionProto() {

  2025.       OnConstruction();

  2026.     }

  2027. 

  2028.     partial void OnConstruction();

  2029. 

  2030.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2031.     public ThreadPoolOptionProto(ThreadPoolOptionProto other) : this() {

  2032.       numThreads_ = other.numThreads_;

  2033.       globalName_ = other.globalName_;

  2034.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  2035.     }

  2036. 

  2037.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2038.     public ThreadPoolOptionProto Clone() {

  2039.       return new ThreadPoolOptionProto(this);

  2040.     }

  2041. 

  2042.     /// <summary>Field number for the "num_threads" field.</summary>

  2043.     public const int NumThreadsFieldNumber = 1;

  2044.     private int numThreads_;

  2045.     /// <summary>

  2046.     /// The number of threads in the pool.

  2047.     ///

  2048.     /// 0 means the system picks a value based on where this option proto is used

  2049.     /// (see the declaration of the specific field for more info).

  2050.     /// </summary>

  2051.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2052.     public int NumThreads {

  2053.       get { return numThreads_; }

  2054.       set {

  2055.         numThreads_ = value;

  2056.       }

  2057.     }

  2058. 

  2059.     /// <summary>Field number for the "global_name" field.</summary>

  2060.     public const int GlobalNameFieldNumber = 2;

  2061.     private string globalName_ = "";

  2062.     /// <summary>

  2063.     /// The global name of the threadpool.

  2064.     ///

  2065.     /// If empty, then the threadpool is made and used according to the scope it's

  2066.     /// in - e.g., for a session threadpool, it is used by that session only.

  2067.     ///

  2068.     /// If non-empty, then:

  2069.     /// - a global threadpool associated with this name is looked

  2070.     ///   up or created. This allows, for example, sharing one threadpool across

  2071.     ///   many sessions (e.g., like the default behavior, if

  2072.     ///   inter_op_parallelism_threads is not configured), but still partitioning

  2073.     ///   into a large and small pool.

  2074.     /// - if the threadpool for this global_name already exists, then it is an

  2075.     ///   error if the existing pool was created using a different num_threads

  2076.     ///   value as is specified on this call.

  2077.     /// - threadpools created this way are never garbage collected.

  2078.     /// </summary>

  2079.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2080.     public string GlobalName {

  2081.       get { return globalName_; }

  2082.       set {

  2083.         globalName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  2084.       }

  2085.     }

  2086. 

  2087.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2088.     public override bool Equals(object other) {

  2089.       return Equals(other as ThreadPoolOptionProto);

  2090.     }

  2091. 

  2092.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2093.     public bool Equals(ThreadPoolOptionProto other) {

  2094.       if (ReferenceEquals(other, null)) {

  2095.         return false;

  2096.       }

  2097.       if (ReferenceEquals(other, this)) {

  2098.         return true;

  2099.       }

  2100.       if (NumThreads != other.NumThreads) return false;

  2101.       if (GlobalName != other.GlobalName) return false;

  2102.       return Equals(_unknownFields, other._unknownFields);

  2103.     }

  2104. 

  2105.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2106.     public override int GetHashCode() {

  2107.       int hash = 1;

  2108.       if (NumThreads != 0) hash ^= NumThreads.GetHashCode();

  2109.       if (GlobalName.Length != 0) hash ^= GlobalName.GetHashCode();

  2110.       if (_unknownFields != null) {

  2111.         hash ^= _unknownFields.GetHashCode();

  2112.       }

  2113.       return hash;

  2114.     }

  2115. 

  2116.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2117.     public override string ToString() {

  2118.       return pb::JsonFormatter.ToDiagnosticString(this);

  2119.     }

  2120. 

  2121.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2122.     public void WriteTo(pb::CodedOutputStream output) {

  2123.       if (NumThreads != 0) {

  2124.         output.WriteRawTag(8);

  2125.         output.WriteInt32(NumThreads);

  2126.       }

  2127.       if (GlobalName.Length != 0) {

  2128.         output.WriteRawTag(18);

  2129.         output.WriteString(GlobalName);

  2130.       }

  2131.       if (_unknownFields != null) {

  2132.         _unknownFields.WriteTo(output);

  2133.       }

  2134.     }

  2135. 

  2136.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2137.     public int CalculateSize() {

  2138.       int size = 0;

  2139.       if (NumThreads != 0) {

  2140.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumThreads);

  2141.       }

  2142.       if (GlobalName.Length != 0) {

  2143.         size += 1 + pb::CodedOutputStream.ComputeStringSize(GlobalName);

  2144.       }

  2145.       if (_unknownFields != null) {

  2146.         size += _unknownFields.CalculateSize();

  2147.       }

  2148.       return size;

  2149.     }

  2150. 

  2151.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2152.     public void MergeFrom(ThreadPoolOptionProto other) {

  2153.       if (other == null) {

  2154.         return;

  2155.       }

  2156.       if (other.NumThreads != 0) {

  2157.         NumThreads = other.NumThreads;

  2158.       }

  2159.       if (other.GlobalName.Length != 0) {

  2160.         GlobalName = other.GlobalName;

  2161.       }

  2162.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  2163.     }

  2164. 

  2165.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2166.     public void MergeFrom(pb::CodedInputStream input) {

  2167.       uint tag;

  2168.       while ((tag = input.ReadTag()) != 0) {

  2169.         switch(tag) {

  2170.           default:

  2171.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  2172.             break;

  2173.           case 8: {

  2174.             NumThreads = input.ReadInt32();

  2175.             break;

  2176.           }

  2177.           case 18: {

  2178.             GlobalName = input.ReadString();

  2179.             break;

  2180.           }

  2181.         }

  2182.       }

  2183.     }

  2184. 

  2185.   }

  2186. 

  2187.   public sealed partial class RPCOptions : pb::IMessage<RPCOptions> {

  2188.     private static readonly pb::MessageParser<RPCOptions> _parser = new pb::MessageParser<RPCOptions>(() => new RPCOptions());

  2189.     private pb::UnknownFieldSet _unknownFields;

  2190.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2191.     public static pb::MessageParser<RPCOptions> Parser { get { return _parser; } }

  2192. 

  2193.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2194.     public static pbr::MessageDescriptor Descriptor {

  2195.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[4]; }

  2196.     }

  2197. 

  2198.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2199.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  2200.       get { return Descriptor; }

  2201.     }

  2202. 

  2203.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2204.     public RPCOptions() {

  2205.       OnConstruction();

  2206.     }

  2207. 

  2208.     partial void OnConstruction();

  2209. 

  2210.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2211.     public RPCOptions(RPCOptions other) : this() {

  2212.       useRpcForInprocessMaster_ = other.useRpcForInprocessMaster_;

  2213.       compressionAlgorithm_ = other.compressionAlgorithm_;

  2214.       compressionLevel_ = other.compressionLevel_;

  2215.       cacheRpcResponse_ = other.cacheRpcResponse_;

  2216.       disableSessionConnectionSharing_ = other.disableSessionConnectionSharing_;

  2217.       numChannelsPerTarget_ = other.numChannelsPerTarget_;

  2218.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  2219.     }

  2220. 

  2221.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2222.     public RPCOptions Clone() {

  2223.       return new RPCOptions(this);

  2224.     }

  2225. 

  2226.     /// <summary>Field number for the "use_rpc_for_inprocess_master" field.</summary>

  2227.     public const int UseRpcForInprocessMasterFieldNumber = 1;

  2228.     private bool useRpcForInprocessMaster_;

  2229.     /// <summary>

  2230.     /// If true, always use RPC to contact the session target.

  2231.     ///

  2232.     /// If false (the default option), TensorFlow may use an optimized

  2233.     /// transport for client-master communication that avoids the RPC

  2234.     /// stack. This option is primarily for used testing the RPC stack.

  2235.     /// </summary>

  2236.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2237.     public bool UseRpcForInprocessMaster {

  2238.       get { return useRpcForInprocessMaster_; }

  2239.       set {

  2240.         useRpcForInprocessMaster_ = value;

  2241.       }

  2242.     }

  2243. 

  2244.     /// <summary>Field number for the "compression_algorithm" field.</summary>

  2245.     public const int CompressionAlgorithmFieldNumber = 2;

  2246.     private string compressionAlgorithm_ = "";

  2247.     /// <summary>

  2248.     /// The compression algorithm to be used. One of "deflate", "gzip".

  2249.     /// </summary>

  2250.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2251.     public string CompressionAlgorithm {

  2252.       get { return compressionAlgorithm_; }

  2253.       set {

  2254.         compressionAlgorithm_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  2255.       }

  2256.     }

  2257. 

  2258.     /// <summary>Field number for the "compression_level" field.</summary>

  2259.     public const int CompressionLevelFieldNumber = 3;

  2260.     private int compressionLevel_;

  2261.     /// <summary>

  2262.     /// If compression_algorithm is set, the compression level to be used.

  2263.     /// From 0 (no compression), up to 3.

  2264.     /// </summary>

  2265.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2266.     public int CompressionLevel {

  2267.       get { return compressionLevel_; }

  2268.       set {

  2269.         compressionLevel_ = value;

  2270.       }

  2271.     }

  2272. 

  2273.     /// <summary>Field number for the "cache_rpc_response" field.</summary>

  2274.     public const int CacheRpcResponseFieldNumber = 4;

  2275.     private bool cacheRpcResponse_;

  2276.     /// <summary>

  2277.     /// Setting cache_rpc_response to true will enable sender side caching of

  2278.     /// response for RecvTensorAsync and RecvBufAsync to allow receiver to retry

  2279.     /// requests . This is only necessary when the network fabric is experiencing a

  2280.     /// significant error rate.  Without it we'll fail a step on an network error,

  2281.     /// while with it we'll be able to complete long steps (like complex

  2282.     /// initializations) in the face of some network errors during RecvTensor.

  2283.     /// </summary>

  2284.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2285.     public bool CacheRpcResponse {

  2286.       get { return cacheRpcResponse_; }

  2287.       set {

  2288.         cacheRpcResponse_ = value;

  2289.       }

  2290.     }

  2291. 

  2292.     /// <summary>Field number for the "disable_session_connection_sharing" field.</summary>

  2293.     public const int DisableSessionConnectionSharingFieldNumber = 5;

  2294.     private bool disableSessionConnectionSharing_;

  2295.     /// <summary>

  2296.     /// Disables TCP connection sharing when opening a new RPC channel.

  2297.     /// </summary>

  2298.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2299.     public bool DisableSessionConnectionSharing {

  2300.       get { return disableSessionConnectionSharing_; }

  2301.       set {

  2302.         disableSessionConnectionSharing_ = value;

  2303.       }

  2304.     }

  2305. 

  2306.     /// <summary>Field number for the "num_channels_per_target" field.</summary>

  2307.     public const int NumChannelsPerTargetFieldNumber = 6;

  2308.     private int numChannelsPerTarget_;

  2309.     /// <summary>

  2310.     /// Setting num_channels_per_target > 0 allows uses of multiple channels to

  2311.     /// communicate to the same target. This can be used to improve the aggregate

  2312.     /// throughput on high speed links (e.g 100G) where single connection is not

  2313.     /// sufficient to maximize link utilization. Note that a single RPC only goes

  2314.     /// on a single channel, this only helps in situations where there are multiple

  2315.     /// transfers to the same target overlapping in time.

  2316.     /// </summary>

  2317.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2318.     public int NumChannelsPerTarget {

  2319.       get { return numChannelsPerTarget_; }

  2320.       set {

  2321.         numChannelsPerTarget_ = value;

  2322.       }

  2323.     }

  2324. 

  2325.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2326.     public override bool Equals(object other) {

  2327.       return Equals(other as RPCOptions);

  2328.     }

  2329. 

  2330.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2331.     public bool Equals(RPCOptions other) {

  2332.       if (ReferenceEquals(other, null)) {

  2333.         return false;

  2334.       }

  2335.       if (ReferenceEquals(other, this)) {

  2336.         return true;

  2337.       }

  2338.       if (UseRpcForInprocessMaster != other.UseRpcForInprocessMaster) return false;

  2339.       if (CompressionAlgorithm != other.CompressionAlgorithm) return false;

  2340.       if (CompressionLevel != other.CompressionLevel) return false;

  2341.       if (CacheRpcResponse != other.CacheRpcResponse) return false;

  2342.       if (DisableSessionConnectionSharing != other.DisableSessionConnectionSharing) return false;

  2343.       if (NumChannelsPerTarget != other.NumChannelsPerTarget) return false;

  2344.       return Equals(_unknownFields, other._unknownFields);

  2345.     }

  2346. 

  2347.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2348.     public override int GetHashCode() {

  2349.       int hash = 1;

  2350.       if (UseRpcForInprocessMaster != false) hash ^= UseRpcForInprocessMaster.GetHashCode();

  2351.       if (CompressionAlgorithm.Length != 0) hash ^= CompressionAlgorithm.GetHashCode();

  2352.       if (CompressionLevel != 0) hash ^= CompressionLevel.GetHashCode();

  2353.       if (CacheRpcResponse != false) hash ^= CacheRpcResponse.GetHashCode();

  2354.       if (DisableSessionConnectionSharing != false) hash ^= DisableSessionConnectionSharing.GetHashCode();

  2355.       if (NumChannelsPerTarget != 0) hash ^= NumChannelsPerTarget.GetHashCode();

  2356.       if (_unknownFields != null) {

  2357.         hash ^= _unknownFields.GetHashCode();

  2358.       }

  2359.       return hash;

  2360.     }

  2361. 

  2362.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2363.     public override string ToString() {

  2364.       return pb::JsonFormatter.ToDiagnosticString(this);

  2365.     }

  2366. 

  2367.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2368.     public void WriteTo(pb::CodedOutputStream output) {

  2369.       if (UseRpcForInprocessMaster != false) {

  2370.         output.WriteRawTag(8);

  2371.         output.WriteBool(UseRpcForInprocessMaster);

  2372.       }

  2373.       if (CompressionAlgorithm.Length != 0) {

  2374.         output.WriteRawTag(18);

  2375.         output.WriteString(CompressionAlgorithm);

  2376.       }

  2377.       if (CompressionLevel != 0) {

  2378.         output.WriteRawTag(24);

  2379.         output.WriteInt32(CompressionLevel);

  2380.       }

  2381.       if (CacheRpcResponse != false) {

  2382.         output.WriteRawTag(32);

  2383.         output.WriteBool(CacheRpcResponse);

  2384.       }

  2385.       if (DisableSessionConnectionSharing != false) {

  2386.         output.WriteRawTag(40);

  2387.         output.WriteBool(DisableSessionConnectionSharing);

  2388.       }

  2389.       if (NumChannelsPerTarget != 0) {

  2390.         output.WriteRawTag(48);

  2391.         output.WriteInt32(NumChannelsPerTarget);

  2392.       }

  2393.       if (_unknownFields != null) {

  2394.         _unknownFields.WriteTo(output);

  2395.       }

  2396.     }

  2397. 

  2398.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2399.     public int CalculateSize() {

  2400.       int size = 0;

  2401.       if (UseRpcForInprocessMaster != false) {

  2402.         size += 1 + 1;

  2403.       }

  2404.       if (CompressionAlgorithm.Length != 0) {

  2405.         size += 1 + pb::CodedOutputStream.ComputeStringSize(CompressionAlgorithm);

  2406.       }

  2407.       if (CompressionLevel != 0) {

  2408.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(CompressionLevel);

  2409.       }

  2410.       if (CacheRpcResponse != false) {

  2411.         size += 1 + 1;

  2412.       }

  2413.       if (DisableSessionConnectionSharing != false) {

  2414.         size += 1 + 1;

  2415.       }

  2416.       if (NumChannelsPerTarget != 0) {

  2417.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumChannelsPerTarget);

  2418.       }

  2419.       if (_unknownFields != null) {

  2420.         size += _unknownFields.CalculateSize();

  2421.       }

  2422.       return size;

  2423.     }

  2424. 

  2425.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2426.     public void MergeFrom(RPCOptions other) {

  2427.       if (other == null) {

  2428.         return;

  2429.       }

  2430.       if (other.UseRpcForInprocessMaster != false) {

  2431.         UseRpcForInprocessMaster = other.UseRpcForInprocessMaster;

  2432.       }

  2433.       if (other.CompressionAlgorithm.Length != 0) {

  2434.         CompressionAlgorithm = other.CompressionAlgorithm;

  2435.       }

  2436.       if (other.CompressionLevel != 0) {

  2437.         CompressionLevel = other.CompressionLevel;

  2438.       }

  2439.       if (other.CacheRpcResponse != false) {

  2440.         CacheRpcResponse = other.CacheRpcResponse;

  2441.       }

  2442.       if (other.DisableSessionConnectionSharing != false) {

  2443.         DisableSessionConnectionSharing = other.DisableSessionConnectionSharing;

  2444.       }

  2445.       if (other.NumChannelsPerTarget != 0) {

  2446.         NumChannelsPerTarget = other.NumChannelsPerTarget;

  2447.       }

  2448.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  2449.     }

  2450. 

  2451.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2452.     public void MergeFrom(pb::CodedInputStream input) {

  2453.       uint tag;

  2454.       while ((tag = input.ReadTag()) != 0) {

  2455.         switch(tag) {

  2456.           default:

  2457.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  2458.             break;

  2459.           case 8: {

  2460.             UseRpcForInprocessMaster = input.ReadBool();

  2461.             break;

  2462.           }

  2463.           case 18: {

  2464.             CompressionAlgorithm = input.ReadString();

  2465.             break;

  2466.           }

  2467.           case 24: {

  2468.             CompressionLevel = input.ReadInt32();

  2469.             break;

  2470.           }

  2471.           case 32: {

  2472.             CacheRpcResponse = input.ReadBool();

  2473.             break;

  2474.           }

  2475.           case 40: {

  2476.             DisableSessionConnectionSharing = input.ReadBool();

  2477.             break;

  2478.           }

  2479.           case 48: {

  2480.             NumChannelsPerTarget = input.ReadInt32();

  2481.             break;

  2482.           }

  2483.         }

  2484.       }

  2485.     }

  2486. 

  2487.   }

  2488. 

  2489.   /// <summary>

  2490.   /// Metadata about the session.

  2491.   ///

  2492.   /// This can be used by the runtime and the Ops for debugging, monitoring, etc.

  2493.   ///

  2494.   /// The (name, version) tuple is expected to be a unique identifier for

  2495.   /// sessions within the same process.

  2496.   ///

  2497.   /// NOTE: This is currently used and propagated only by the direct session.

  2498.   /// </summary>

  2499.   public sealed partial class SessionMetadata : pb::IMessage<SessionMetadata> {

  2500.     private static readonly pb::MessageParser<SessionMetadata> _parser = new pb::MessageParser<SessionMetadata>(() => new SessionMetadata());

  2501.     private pb::UnknownFieldSet _unknownFields;

  2502.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2503.     public static pb::MessageParser<SessionMetadata> Parser { get { return _parser; } }

  2504. 

  2505.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2506.     public static pbr::MessageDescriptor Descriptor {

  2507.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[5]; }

  2508.     }

  2509. 

  2510.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2511.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  2512.       get { return Descriptor; }

  2513.     }

  2514. 

  2515.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2516.     public SessionMetadata() {

  2517.       OnConstruction();

  2518.     }

  2519. 

  2520.     partial void OnConstruction();

  2521. 

  2522.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2523.     public SessionMetadata(SessionMetadata other) : this() {

  2524.       name_ = other.name_;

  2525.       version_ = other.version_;

  2526.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  2527.     }

  2528. 

  2529.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2530.     public SessionMetadata Clone() {

  2531.       return new SessionMetadata(this);

  2532.     }

  2533. 

  2534.     /// <summary>Field number for the "name" field.</summary>

  2535.     public const int NameFieldNumber = 1;

  2536.     private string name_ = "";

  2537.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2538.     public string Name {

  2539.       get { return name_; }

  2540.       set {

  2541.         name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  2542.       }

  2543.     }

  2544. 

  2545.     /// <summary>Field number for the "version" field.</summary>

  2546.     public const int VersionFieldNumber = 2;

  2547.     private long version_;

  2548.     /// <summary>

  2549.     /// The version is optional. If set, needs to be >= 0.

  2550.     /// </summary>

  2551.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2552.     public long Version {

  2553.       get { return version_; }

  2554.       set {

  2555.         version_ = value;

  2556.       }

  2557.     }

  2558. 

  2559.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2560.     public override bool Equals(object other) {

  2561.       return Equals(other as SessionMetadata);

  2562.     }

  2563. 

  2564.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2565.     public bool Equals(SessionMetadata other) {

  2566.       if (ReferenceEquals(other, null)) {

  2567.         return false;

  2568.       }

  2569.       if (ReferenceEquals(other, this)) {

  2570.         return true;

  2571.       }

  2572.       if (Name != other.Name) return false;

  2573.       if (Version != other.Version) return false;

  2574.       return Equals(_unknownFields, other._unknownFields);

  2575.     }

  2576. 

  2577.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2578.     public override int GetHashCode() {

  2579.       int hash = 1;

  2580.       if (Name.Length != 0) hash ^= Name.GetHashCode();

  2581.       if (Version != 0L) hash ^= Version.GetHashCode();

  2582.       if (_unknownFields != null) {

  2583.         hash ^= _unknownFields.GetHashCode();

  2584.       }

  2585.       return hash;

  2586.     }

  2587. 

  2588.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2589.     public override string ToString() {

  2590.       return pb::JsonFormatter.ToDiagnosticString(this);

  2591.     }

  2592. 

  2593.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2594.     public void WriteTo(pb::CodedOutputStream output) {

  2595.       if (Name.Length != 0) {

  2596.         output.WriteRawTag(10);

  2597.         output.WriteString(Name);

  2598.       }

  2599.       if (Version != 0L) {

  2600.         output.WriteRawTag(16);

  2601.         output.WriteInt64(Version);

  2602.       }

  2603.       if (_unknownFields != null) {

  2604.         _unknownFields.WriteTo(output);

  2605.       }

  2606.     }

  2607. 

  2608.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2609.     public int CalculateSize() {

  2610.       int size = 0;

  2611.       if (Name.Length != 0) {

  2612.         size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);

  2613.       }

  2614.       if (Version != 0L) {

  2615.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(Version);

  2616.       }

  2617.       if (_unknownFields != null) {

  2618.         size += _unknownFields.CalculateSize();

  2619.       }

  2620.       return size;

  2621.     }

  2622. 

  2623.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2624.     public void MergeFrom(SessionMetadata other) {

  2625.       if (other == null) {

  2626.         return;

  2627.       }

  2628.       if (other.Name.Length != 0) {

  2629.         Name = other.Name;

  2630.       }

  2631.       if (other.Version != 0L) {

  2632.         Version = other.Version;

  2633.       }

  2634.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  2635.     }

  2636. 

  2637.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2638.     public void MergeFrom(pb::CodedInputStream input) {

  2639.       uint tag;

  2640.       while ((tag = input.ReadTag()) != 0) {

  2641.         switch(tag) {

  2642.           default:

  2643.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  2644.             break;

  2645.           case 10: {

  2646.             Name = input.ReadString();

  2647.             break;

  2648.           }

  2649.           case 16: {

  2650.             Version = input.ReadInt64();

  2651.             break;

  2652.           }

  2653.         }

  2654.       }

  2655.     }

  2656. 

  2657.   }

  2658. 

  2659.   /// <summary>

  2660.   /// Session configuration parameters.

  2661.   /// The system picks appropriate values for fields that are not set.

  2662.   /// </summary>

  2663.   public sealed partial class ConfigProto : pb::IMessage<ConfigProto> {

  2664.     private static readonly pb::MessageParser<ConfigProto> _parser = new pb::MessageParser<ConfigProto>(() => new ConfigProto());

  2665.     private pb::UnknownFieldSet _unknownFields;

  2666.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2667.     public static pb::MessageParser<ConfigProto> Parser { get { return _parser; } }

  2668. 

  2669.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2670.     public static pbr::MessageDescriptor Descriptor {

  2671.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[6]; }

  2672.     }

  2673. 

  2674.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2675.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  2676.       get { return Descriptor; }

  2677.     }

  2678. 

  2679.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2680.     public ConfigProto() {

  2681.       OnConstruction();

  2682.     }

  2683. 

  2684.     partial void OnConstruction();

  2685. 

  2686.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2687.     public ConfigProto(ConfigProto other) : this() {

  2688.       deviceCount_ = other.deviceCount_.Clone();

  2689.       intraOpParallelismThreads_ = other.intraOpParallelismThreads_;

  2690.       interOpParallelismThreads_ = other.interOpParallelismThreads_;

  2691.       usePerSessionThreads_ = other.usePerSessionThreads_;

  2692.       sessionInterOpThreadPool_ = other.sessionInterOpThreadPool_.Clone();

  2693.       placementPeriod_ = other.placementPeriod_;

  2694.       deviceFilters_ = other.deviceFilters_.Clone();

  2695.       gpuOptions_ = other.gpuOptions_ != null ? other.gpuOptions_.Clone() : null;

  2696.       allowSoftPlacement_ = other.allowSoftPlacement_;

  2697.       logDevicePlacement_ = other.logDevicePlacement_;

  2698.       graphOptions_ = other.graphOptions_ != null ? other.graphOptions_.Clone() : null;

  2699.       operationTimeoutInMs_ = other.operationTimeoutInMs_;

  2700.       rpcOptions_ = other.rpcOptions_ != null ? other.rpcOptions_.Clone() : null;

  2701.       clusterDef_ = other.clusterDef_ != null ? other.clusterDef_.Clone() : null;

  2702.       isolateSessionState_ = other.isolateSessionState_;

  2703.       shareClusterDevicesInSession_ = other.shareClusterDevicesInSession_;

  2704.       experimental_ = other.experimental_ != null ? other.experimental_.Clone() : null;

  2705.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  2706.     }

  2707. 

  2708.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2709.     public ConfigProto Clone() {

  2710.       return new ConfigProto(this);

  2711.     }

  2712. 

  2713.     /// <summary>Field number for the "device_count" field.</summary>

  2714.     public const int DeviceCountFieldNumber = 1;

  2715.     private static readonly pbc::MapField<string, int>.Codec _map_deviceCount_codec

  2716.         = new pbc::MapField<string, int>.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForInt32(16, 0), 10);

  2717.     private readonly pbc::MapField<string, int> deviceCount_ = new pbc::MapField<string, int>();

  2718.     /// <summary>

  2719.     /// Map from device type name (e.g., "CPU" or "GPU" ) to maximum

  2720.     /// number of devices of that type to use.  If a particular device

  2721.     /// type is not found in the map, the system picks an appropriate

  2722.     /// number.

  2723.     /// </summary>

  2724.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2725.     public pbc::MapField<string, int> DeviceCount {

  2726.       get { return deviceCount_; }

  2727.     }

  2728. 

  2729.     /// <summary>Field number for the "intra_op_parallelism_threads" field.</summary>

  2730.     public const int IntraOpParallelismThreadsFieldNumber = 2;

  2731.     private int intraOpParallelismThreads_;

  2732.     /// <summary>

  2733.     /// The execution of an individual op (for some op types) can be

  2734.     /// parallelized on a pool of intra_op_parallelism_threads.

  2735.     /// 0 means the system picks an appropriate number.

  2736.     ///

  2737.     /// If you create an ordinary session, e.g., from Python or C++,

  2738.     /// then there is exactly one intra op thread pool per process.

  2739.     /// The first session created determines the number of threads in this pool.

  2740.     /// All subsequent sessions reuse/share this one global pool.

  2741.     ///

  2742.     /// There are notable exceptions to the default behavior described above:

  2743.     /// 1. There is an environment variable  for overriding this thread pool,

  2744.     ///    named TF_OVERRIDE_GLOBAL_THREADPOOL.

  2745.     /// 2. When connecting to a server, such as a remote `tf.train.Server`

  2746.     ///    instance, then this option will be ignored altogether.

  2747.     /// </summary>

  2748.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2749.     public int IntraOpParallelismThreads {

  2750.       get { return intraOpParallelismThreads_; }

  2751.       set {

  2752.         intraOpParallelismThreads_ = value;

  2753.       }

  2754.     }

  2755. 

  2756.     /// <summary>Field number for the "inter_op_parallelism_threads" field.</summary>

  2757.     public const int InterOpParallelismThreadsFieldNumber = 5;

  2758.     private int interOpParallelismThreads_;

  2759.     /// <summary>

  2760.     /// Nodes that perform blocking operations are enqueued on a pool of

  2761.     /// inter_op_parallelism_threads available in each process.

  2762.     ///

  2763.     /// 0 means the system picks an appropriate number.

  2764.     /// Negative means all operations are performed in caller's thread.

  2765.     ///

  2766.     /// Note that the first Session created in the process sets the

  2767.     /// number of threads for all future sessions unless use_per_session_threads is

  2768.     /// true or session_inter_op_thread_pool is configured.

  2769.     /// </summary>

  2770.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2771.     public int InterOpParallelismThreads {

  2772.       get { return interOpParallelismThreads_; }

  2773.       set {

  2774.         interOpParallelismThreads_ = value;

  2775.       }

  2776.     }

  2777. 

  2778.     /// <summary>Field number for the "use_per_session_threads" field.</summary>

  2779.     public const int UsePerSessionThreadsFieldNumber = 9;

  2780.     private bool usePerSessionThreads_;

  2781.     /// <summary>

  2782.     /// If true, use a new set of threads for this session rather than the global

  2783.     /// pool of threads. Only supported by direct sessions.

  2784.     ///

  2785.     /// If false, use the global threads created by the first session, or the

  2786.     /// per-session thread pools configured by session_inter_op_thread_pool.

  2787.     ///

  2788.     /// This option is deprecated. The same effect can be achieved by setting

  2789.     /// session_inter_op_thread_pool to have one element, whose num_threads equals

  2790.     /// inter_op_parallelism_threads.

  2791.     /// </summary>

  2792.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2793.     public bool UsePerSessionThreads {

  2794.       get { return usePerSessionThreads_; }

  2795.       set {

  2796.         usePerSessionThreads_ = value;

  2797.       }

  2798.     }

  2799. 

  2800.     /// <summary>Field number for the "session_inter_op_thread_pool" field.</summary>

  2801.     public const int SessionInterOpThreadPoolFieldNumber = 12;

  2802.     private static readonly pb::FieldCodec<global::Tensorflow.ThreadPoolOptionProto> _repeated_sessionInterOpThreadPool_codec

  2803.         = pb::FieldCodec.ForMessage(98, global::Tensorflow.ThreadPoolOptionProto.Parser);

  2804.     private readonly pbc::RepeatedField<global::Tensorflow.ThreadPoolOptionProto> sessionInterOpThreadPool_ = new pbc::RepeatedField<global::Tensorflow.ThreadPoolOptionProto>();

  2805.     /// <summary>

  2806.     /// This option is experimental - it may be replaced with a different mechanism

  2807.     /// in the future.

  2808.     ///

  2809.     /// Configures session thread pools. If this is configured, then RunOptions for

  2810.     /// a Run call can select the thread pool to use.

  2811.     ///

  2812.     /// The intended use is for when some session invocations need to run in a

  2813.     /// background pool limited to a small number of threads:

  2814.     /// - For example, a session may be configured to have one large pool (for

  2815.     /// regular compute) and one small pool (for periodic, low priority work);

  2816.     /// using the small pool is currently the mechanism for limiting the inter-op

  2817.     /// parallelism of the low priority work.  Note that it does not limit the

  2818.     /// parallelism of work spawned by a single op kernel implementation.

  2819.     /// - Using this setting is normally not needed in training, but may help some

  2820.     /// serving use cases.

  2821.     /// - It is also generally recommended to set the global_name field of this

  2822.     /// proto, to avoid creating multiple large pools. It is typically better to

  2823.     /// run the non-low-priority work, even across sessions, in a single large

  2824.     /// pool.

  2825.     /// </summary>

  2826.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2827.     public pbc::RepeatedField<global::Tensorflow.ThreadPoolOptionProto> SessionInterOpThreadPool {

  2828.       get { return sessionInterOpThreadPool_; }

  2829.     }

  2830. 

  2831.     /// <summary>Field number for the "placement_period" field.</summary>

  2832.     public const int PlacementPeriodFieldNumber = 3;

  2833.     private int placementPeriod_;

  2834.     /// <summary>

  2835.     /// Assignment of Nodes to Devices is recomputed every placement_period

  2836.     /// steps until the system warms up (at which point the recomputation

  2837.     /// typically slows down automatically).

  2838.     /// </summary>

  2839.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2840.     public int PlacementPeriod {

  2841.       get { return placementPeriod_; }

  2842.       set {

  2843.         placementPeriod_ = value;

  2844.       }

  2845.     }

  2846. 

  2847.     /// <summary>Field number for the "device_filters" field.</summary>

  2848.     public const int DeviceFiltersFieldNumber = 4;

  2849.     private static readonly pb::FieldCodec<string> _repeated_deviceFilters_codec

  2850.         = pb::FieldCodec.ForString(34);

  2851.     private readonly pbc::RepeatedField<string> deviceFilters_ = new pbc::RepeatedField<string>();

  2852.     /// <summary>

  2853.     /// When any filters are present sessions will ignore all devices which do not

  2854.     /// match the filters. Each filter can be partially specified, e.g. "/job:ps"

  2855.     /// "/job:worker/replica:3", etc.

  2856.     /// </summary>

  2857.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2858.     public pbc::RepeatedField<string> DeviceFilters {

  2859.       get { return deviceFilters_; }

  2860.     }

  2861. 

  2862.     /// <summary>Field number for the "gpu_options" field.</summary>

  2863.     public const int GpuOptionsFieldNumber = 6;

  2864.     private global::Tensorflow.GPUOptions gpuOptions_;

  2865.     /// <summary>

  2866.     /// Options that apply to all GPUs.

  2867.     /// </summary>

  2868.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2869.     public global::Tensorflow.GPUOptions GpuOptions {

  2870.       get { return gpuOptions_; }

  2871.       set {

  2872.         gpuOptions_ = value;

  2873.       }

  2874.     }

  2875. 

  2876.     /// <summary>Field number for the "allow_soft_placement" field.</summary>

  2877.     public const int AllowSoftPlacementFieldNumber = 7;

  2878.     private bool allowSoftPlacement_;

  2879.     /// <summary>

  2880.     /// Whether soft placement is allowed. If allow_soft_placement is true,

  2881.     /// an op will be placed on CPU if

  2882.     ///   1. there's no GPU implementation for the OP

  2883.     /// or

  2884.     ///   2. no GPU devices are known or registered

  2885.     /// or

  2886.     ///   3. need to co-locate with reftype input(s) which are from CPU.

  2887.     /// </summary>

  2888.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2889.     public bool AllowSoftPlacement {

  2890.       get { return allowSoftPlacement_; }

  2891.       set {

  2892.         allowSoftPlacement_ = value;

  2893.       }

  2894.     }

  2895. 

  2896.     /// <summary>Field number for the "log_device_placement" field.</summary>

  2897.     public const int LogDevicePlacementFieldNumber = 8;

  2898.     private bool logDevicePlacement_;

  2899.     /// <summary>

  2900.     /// Whether device placements should be logged.

  2901.     /// </summary>

  2902.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2903.     public bool LogDevicePlacement {

  2904.       get { return logDevicePlacement_; }

  2905.       set {

  2906.         logDevicePlacement_ = value;

  2907.       }

  2908.     }

  2909. 

  2910.     /// <summary>Field number for the "graph_options" field.</summary>

  2911.     public const int GraphOptionsFieldNumber = 10;

  2912.     private global::Tensorflow.GraphOptions graphOptions_;

  2913.     /// <summary>

  2914.     /// Options that apply to all graphs.

  2915.     /// </summary>

  2916.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2917.     public global::Tensorflow.GraphOptions GraphOptions {

  2918.       get { return graphOptions_; }

  2919.       set {

  2920.         graphOptions_ = value;

  2921.       }

  2922.     }

  2923. 

  2924.     /// <summary>Field number for the "operation_timeout_in_ms" field.</summary>

  2925.     public const int OperationTimeoutInMsFieldNumber = 11;

  2926.     private long operationTimeoutInMs_;

  2927.     /// <summary>

  2928.     /// Global timeout for all blocking operations in this session.  If non-zero,

  2929.     /// and not overridden on a per-operation basis, this value will be used as the

  2930.     /// deadline for all blocking operations.

  2931.     /// </summary>

  2932.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2933.     public long OperationTimeoutInMs {

  2934.       get { return operationTimeoutInMs_; }

  2935.       set {

  2936.         operationTimeoutInMs_ = value;

  2937.       }

  2938.     }

  2939. 

  2940.     /// <summary>Field number for the "rpc_options" field.</summary>

  2941.     public const int RpcOptionsFieldNumber = 13;

  2942.     private global::Tensorflow.RPCOptions rpcOptions_;

  2943.     /// <summary>

  2944.     /// Options that apply when this session uses the distributed runtime.

  2945.     /// </summary>

  2946.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2947.     public global::Tensorflow.RPCOptions RpcOptions {

  2948.       get { return rpcOptions_; }

  2949.       set {

  2950.         rpcOptions_ = value;

  2951.       }

  2952.     }

  2953. 

  2954.     /// <summary>Field number for the "cluster_def" field.</summary>

  2955.     public const int ClusterDefFieldNumber = 14;

  2956.     private global::Tensorflow.ClusterDef clusterDef_;

  2957.     /// <summary>

  2958.     /// Optional list of all workers to use in this session.

  2959.     /// </summary>

  2960.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2961.     public global::Tensorflow.ClusterDef ClusterDef {

  2962.       get { return clusterDef_; }

  2963.       set {

  2964.         clusterDef_ = value;

  2965.       }

  2966.     }

  2967. 

  2968.     /// <summary>Field number for the "isolate_session_state" field.</summary>

  2969.     public const int IsolateSessionStateFieldNumber = 15;

  2970.     private bool isolateSessionState_;

  2971.     /// <summary>

  2972.     /// If true, any resources such as Variables used in the session will not be

  2973.     /// shared with other sessions. However, when clusterspec propagation is

  2974.     /// enabled, this field is ignored and sessions are always isolated.

  2975.     /// </summary>

  2976.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2977.     public bool IsolateSessionState {

  2978.       get { return isolateSessionState_; }

  2979.       set {

  2980.         isolateSessionState_ = value;

  2981.       }

  2982.     }

  2983. 

  2984.     /// <summary>Field number for the "share_cluster_devices_in_session" field.</summary>

  2985.     public const int ShareClusterDevicesInSessionFieldNumber = 17;

  2986.     private bool shareClusterDevicesInSession_;

  2987.     /// <summary>

  2988.     /// When true, WorkerSessions are created with device attributes from the

  2989.     /// full cluster.

  2990.     /// This is helpful when a worker wants to partition a graph

  2991.     /// (for example during a PartitionedCallOp).

  2992.     /// </summary>

  2993.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  2994.     public bool ShareClusterDevicesInSession {

  2995.       get { return shareClusterDevicesInSession_; }

  2996.       set {

  2997.         shareClusterDevicesInSession_ = value;

  2998.       }

  2999.     }

  3000. 

  3001.     /// <summary>Field number for the "experimental" field.</summary>

  3002.     public const int ExperimentalFieldNumber = 16;

  3003.     private global::Tensorflow.ConfigProto.Types.Experimental experimental_;

  3004.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3005.     public global::Tensorflow.ConfigProto.Types.Experimental Experimental {

  3006.       get { return experimental_; }

  3007.       set {

  3008.         experimental_ = value;

  3009.       }

  3010.     }

  3011. 

  3012.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3013.     public override bool Equals(object other) {

  3014.       return Equals(other as ConfigProto);

  3015.     }

  3016. 

  3017.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3018.     public bool Equals(ConfigProto other) {

  3019.       if (ReferenceEquals(other, null)) {

  3020.         return false;

  3021.       }

  3022.       if (ReferenceEquals(other, this)) {

  3023.         return true;

  3024.       }

  3025.       if (!DeviceCount.Equals(other.DeviceCount)) return false;

  3026.       if (IntraOpParallelismThreads != other.IntraOpParallelismThreads) return false;

  3027.       if (InterOpParallelismThreads != other.InterOpParallelismThreads) return false;

  3028.       if (UsePerSessionThreads != other.UsePerSessionThreads) return false;

  3029.       if(!sessionInterOpThreadPool_.Equals(other.sessionInterOpThreadPool_)) return false;

  3030.       if (PlacementPeriod != other.PlacementPeriod) return false;

  3031.       if(!deviceFilters_.Equals(other.deviceFilters_)) return false;

  3032.       if (!object.Equals(GpuOptions, other.GpuOptions)) return false;

  3033.       if (AllowSoftPlacement != other.AllowSoftPlacement) return false;

  3034.       if (LogDevicePlacement != other.LogDevicePlacement) return false;

  3035.       if (!object.Equals(GraphOptions, other.GraphOptions)) return false;

  3036.       if (OperationTimeoutInMs != other.OperationTimeoutInMs) return false;

  3037.       if (!object.Equals(RpcOptions, other.RpcOptions)) return false;

  3038.       if (!object.Equals(ClusterDef, other.ClusterDef)) return false;

  3039.       if (IsolateSessionState != other.IsolateSessionState) return false;

  3040.       if (ShareClusterDevicesInSession != other.ShareClusterDevicesInSession) return false;

  3041.       if (!object.Equals(Experimental, other.Experimental)) return false;

  3042.       return Equals(_unknownFields, other._unknownFields);

  3043.     }

  3044. 

  3045.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3046.     public override int GetHashCode() {

  3047.       int hash = 1;

  3048.       hash ^= DeviceCount.GetHashCode();

  3049.       if (IntraOpParallelismThreads != 0) hash ^= IntraOpParallelismThreads.GetHashCode();

  3050.       if (InterOpParallelismThreads != 0) hash ^= InterOpParallelismThreads.GetHashCode();

  3051.       if (UsePerSessionThreads != false) hash ^= UsePerSessionThreads.GetHashCode();

  3052.       hash ^= sessionInterOpThreadPool_.GetHashCode();

  3053.       if (PlacementPeriod != 0) hash ^= PlacementPeriod.GetHashCode();

  3054.       hash ^= deviceFilters_.GetHashCode();

  3055.       if (gpuOptions_ != null) hash ^= GpuOptions.GetHashCode();

  3056.       if (AllowSoftPlacement != false) hash ^= AllowSoftPlacement.GetHashCode();

  3057.       if (LogDevicePlacement != false) hash ^= LogDevicePlacement.GetHashCode();

  3058.       if (graphOptions_ != null) hash ^= GraphOptions.GetHashCode();

  3059.       if (OperationTimeoutInMs != 0L) hash ^= OperationTimeoutInMs.GetHashCode();

  3060.       if (rpcOptions_ != null) hash ^= RpcOptions.GetHashCode();

  3061.       if (clusterDef_ != null) hash ^= ClusterDef.GetHashCode();

  3062.       if (IsolateSessionState != false) hash ^= IsolateSessionState.GetHashCode();

  3063.       if (ShareClusterDevicesInSession != false) hash ^= ShareClusterDevicesInSession.GetHashCode();

  3064.       if (experimental_ != null) hash ^= Experimental.GetHashCode();

  3065.       if (_unknownFields != null) {

  3066.         hash ^= _unknownFields.GetHashCode();

  3067.       }

  3068.       return hash;

  3069.     }

  3070. 

  3071.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3072.     public override string ToString() {

  3073.       return pb::JsonFormatter.ToDiagnosticString(this);

  3074.     }

  3075. 

  3076.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3077.     public void WriteTo(pb::CodedOutputStream output) {

  3078.       deviceCount_.WriteTo(output, _map_deviceCount_codec);

  3079.       if (IntraOpParallelismThreads != 0) {

  3080.         output.WriteRawTag(16);

  3081.         output.WriteInt32(IntraOpParallelismThreads);

  3082.       }

  3083.       if (PlacementPeriod != 0) {

  3084.         output.WriteRawTag(24);

  3085.         output.WriteInt32(PlacementPeriod);

  3086.       }

  3087.       deviceFilters_.WriteTo(output, _repeated_deviceFilters_codec);

  3088.       if (InterOpParallelismThreads != 0) {

  3089.         output.WriteRawTag(40);

  3090.         output.WriteInt32(InterOpParallelismThreads);

  3091.       }

  3092.       if (gpuOptions_ != null) {

  3093.         output.WriteRawTag(50);

  3094.         output.WriteMessage(GpuOptions);

  3095.       }

  3096.       if (AllowSoftPlacement != false) {

  3097.         output.WriteRawTag(56);

  3098.         output.WriteBool(AllowSoftPlacement);

  3099.       }

  3100.       if (LogDevicePlacement != false) {

  3101.         output.WriteRawTag(64);

  3102.         output.WriteBool(LogDevicePlacement);

  3103.       }

  3104.       if (UsePerSessionThreads != false) {

  3105.         output.WriteRawTag(72);

  3106.         output.WriteBool(UsePerSessionThreads);

  3107.       }

  3108.       if (graphOptions_ != null) {

  3109.         output.WriteRawTag(82);

  3110.         output.WriteMessage(GraphOptions);

  3111.       }

  3112.       if (OperationTimeoutInMs != 0L) {

  3113.         output.WriteRawTag(88);

  3114.         output.WriteInt64(OperationTimeoutInMs);

  3115.       }

  3116.       sessionInterOpThreadPool_.WriteTo(output, _repeated_sessionInterOpThreadPool_codec);

  3117.       if (rpcOptions_ != null) {

  3118.         output.WriteRawTag(106);

  3119.         output.WriteMessage(RpcOptions);

  3120.       }

  3121.       if (clusterDef_ != null) {

  3122.         output.WriteRawTag(114);

  3123.         output.WriteMessage(ClusterDef);

  3124.       }

  3125.       if (IsolateSessionState != false) {

  3126.         output.WriteRawTag(120);

  3127.         output.WriteBool(IsolateSessionState);

  3128.       }

  3129.       if (experimental_ != null) {

  3130.         output.WriteRawTag(130, 1);

  3131.         output.WriteMessage(Experimental);

  3132.       }

  3133.       if (ShareClusterDevicesInSession != false) {

  3134.         output.WriteRawTag(136, 1);

  3135.         output.WriteBool(ShareClusterDevicesInSession);

  3136.       }

  3137.       if (_unknownFields != null) {

  3138.         _unknownFields.WriteTo(output);

  3139.       }

  3140.     }

  3141. 

  3142.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3143.     public int CalculateSize() {

  3144.       int size = 0;

  3145.       size += deviceCount_.CalculateSize(_map_deviceCount_codec);

  3146.       if (IntraOpParallelismThreads != 0) {

  3147.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(IntraOpParallelismThreads);

  3148.       }

  3149.       if (InterOpParallelismThreads != 0) {

  3150.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(InterOpParallelismThreads);

  3151.       }

  3152.       if (UsePerSessionThreads != false) {

  3153.         size += 1 + 1;

  3154.       }

  3155.       size += sessionInterOpThreadPool_.CalculateSize(_repeated_sessionInterOpThreadPool_codec);

  3156.       if (PlacementPeriod != 0) {

  3157.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(PlacementPeriod);

  3158.       }

  3159.       size += deviceFilters_.CalculateSize(_repeated_deviceFilters_codec);

  3160.       if (gpuOptions_ != null) {

  3161.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(GpuOptions);

  3162.       }

  3163.       if (AllowSoftPlacement != false) {

  3164.         size += 1 + 1;

  3165.       }

  3166.       if (LogDevicePlacement != false) {

  3167.         size += 1 + 1;

  3168.       }

  3169.       if (graphOptions_ != null) {

  3170.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(GraphOptions);

  3171.       }

  3172.       if (OperationTimeoutInMs != 0L) {

  3173.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(OperationTimeoutInMs);

  3174.       }

  3175.       if (rpcOptions_ != null) {

  3176.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(RpcOptions);

  3177.       }

  3178.       if (clusterDef_ != null) {

  3179.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClusterDef);

  3180.       }

  3181.       if (IsolateSessionState != false) {

  3182.         size += 1 + 1;

  3183.       }

  3184.       if (ShareClusterDevicesInSession != false) {

  3185.         size += 2 + 1;

  3186.       }

  3187.       if (experimental_ != null) {

  3188.         size += 2 + pb::CodedOutputStream.ComputeMessageSize(Experimental);

  3189.       }

  3190.       if (_unknownFields != null) {

  3191.         size += _unknownFields.CalculateSize();

  3192.       }

  3193.       return size;

  3194.     }

  3195. 

  3196.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3197.     public void MergeFrom(ConfigProto other) {

  3198.       if (other == null) {

  3199.         return;

  3200.       }

  3201.       deviceCount_.Add(other.deviceCount_);

  3202.       if (other.IntraOpParallelismThreads != 0) {

  3203.         IntraOpParallelismThreads = other.IntraOpParallelismThreads;

  3204.       }

  3205.       if (other.InterOpParallelismThreads != 0) {

  3206.         InterOpParallelismThreads = other.InterOpParallelismThreads;

  3207.       }

  3208.       if (other.UsePerSessionThreads != false) {

  3209.         UsePerSessionThreads = other.UsePerSessionThreads;

  3210.       }

  3211.       sessionInterOpThreadPool_.Add(other.sessionInterOpThreadPool_);

  3212.       if (other.PlacementPeriod != 0) {

  3213.         PlacementPeriod = other.PlacementPeriod;

  3214.       }

  3215.       deviceFilters_.Add(other.deviceFilters_);

  3216.       if (other.gpuOptions_ != null) {

  3217.         if (gpuOptions_ == null) {

  3218.           GpuOptions = new global::Tensorflow.GPUOptions();

  3219.         }

  3220.         GpuOptions.MergeFrom(other.GpuOptions);

  3221.       }

  3222.       if (other.AllowSoftPlacement != false) {

  3223.         AllowSoftPlacement = other.AllowSoftPlacement;

  3224.       }

  3225.       if (other.LogDevicePlacement != false) {

  3226.         LogDevicePlacement = other.LogDevicePlacement;

  3227.       }

  3228.       if (other.graphOptions_ != null) {

  3229.         if (graphOptions_ == null) {

  3230.           GraphOptions = new global::Tensorflow.GraphOptions();

  3231.         }

  3232.         GraphOptions.MergeFrom(other.GraphOptions);

  3233.       }

  3234.       if (other.OperationTimeoutInMs != 0L) {

  3235.         OperationTimeoutInMs = other.OperationTimeoutInMs;

  3236.       }

  3237.       if (other.rpcOptions_ != null) {

  3238.         if (rpcOptions_ == null) {

  3239.           RpcOptions = new global::Tensorflow.RPCOptions();

  3240.         }

  3241.         RpcOptions.MergeFrom(other.RpcOptions);

  3242.       }

  3243.       if (other.clusterDef_ != null) {

  3244.         if (clusterDef_ == null) {

  3245.           ClusterDef = new global::Tensorflow.ClusterDef();

  3246.         }

  3247.         ClusterDef.MergeFrom(other.ClusterDef);

  3248.       }

  3249.       if (other.IsolateSessionState != false) {

  3250.         IsolateSessionState = other.IsolateSessionState;

  3251.       }

  3252.       if (other.ShareClusterDevicesInSession != false) {

  3253.         ShareClusterDevicesInSession = other.ShareClusterDevicesInSession;

  3254.       }

  3255.       if (other.experimental_ != null) {

  3256.         if (experimental_ == null) {

  3257.           Experimental = new global::Tensorflow.ConfigProto.Types.Experimental();

  3258.         }

  3259.         Experimental.MergeFrom(other.Experimental);

  3260.       }

  3261.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  3262.     }

  3263. 

  3264.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3265.     public void MergeFrom(pb::CodedInputStream input) {

  3266.       uint tag;

  3267.       while ((tag = input.ReadTag()) != 0) {

  3268.         switch(tag) {

  3269.           default:

  3270.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  3271.             break;

  3272.           case 10: {

  3273.             deviceCount_.AddEntriesFrom(input, _map_deviceCount_codec);

  3274.             break;

  3275.           }

  3276.           case 16: {

  3277.             IntraOpParallelismThreads = input.ReadInt32();

  3278.             break;

  3279.           }

  3280.           case 24: {

  3281.             PlacementPeriod = input.ReadInt32();

  3282.             break;

  3283.           }

  3284.           case 34: {

  3285.             deviceFilters_.AddEntriesFrom(input, _repeated_deviceFilters_codec);

  3286.             break;

  3287.           }

  3288.           case 40: {

  3289.             InterOpParallelismThreads = input.ReadInt32();

  3290.             break;

  3291.           }

  3292.           case 50: {

  3293.             if (gpuOptions_ == null) {

  3294.               GpuOptions = new global::Tensorflow.GPUOptions();

  3295.             }

  3296.             input.ReadMessage(GpuOptions);

  3297.             break;

  3298.           }

  3299.           case 56: {

  3300.             AllowSoftPlacement = input.ReadBool();

  3301.             break;

  3302.           }

  3303.           case 64: {

  3304.             LogDevicePlacement = input.ReadBool();

  3305.             break;

  3306.           }

  3307.           case 72: {

  3308.             UsePerSessionThreads = input.ReadBool();

  3309.             break;

  3310.           }

  3311.           case 82: {

  3312.             if (graphOptions_ == null) {

  3313.               GraphOptions = new global::Tensorflow.GraphOptions();

  3314.             }

  3315.             input.ReadMessage(GraphOptions);

  3316.             break;

  3317.           }

  3318.           case 88: {

  3319.             OperationTimeoutInMs = input.ReadInt64();

  3320.             break;

  3321.           }

  3322.           case 98: {

  3323.             sessionInterOpThreadPool_.AddEntriesFrom(input, _repeated_sessionInterOpThreadPool_codec);

  3324.             break;

  3325.           }

  3326.           case 106: {

  3327.             if (rpcOptions_ == null) {

  3328.               RpcOptions = new global::Tensorflow.RPCOptions();

  3329.             }

  3330.             input.ReadMessage(RpcOptions);

  3331.             break;

  3332.           }

  3333.           case 114: {

  3334.             if (clusterDef_ == null) {

  3335.               ClusterDef = new global::Tensorflow.ClusterDef();

  3336.             }

  3337.             input.ReadMessage(ClusterDef);

  3338.             break;

  3339.           }

  3340.           case 120: {

  3341.             IsolateSessionState = input.ReadBool();

  3342.             break;

  3343.           }

  3344.           case 130: {

  3345.             if (experimental_ == null) {

  3346.               Experimental = new global::Tensorflow.ConfigProto.Types.Experimental();

  3347.             }

  3348.             input.ReadMessage(Experimental);

  3349.             break;

  3350.           }

  3351.           case 136: {

  3352.             ShareClusterDevicesInSession = input.ReadBool();

  3353.             break;

  3354.           }

  3355.         }

  3356.       }

  3357.     }

  3358. 

  3359.     #region Nested types

  3360.     /// <summary>Container for nested types declared in the ConfigProto message type.</summary>

  3361.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3362.     public static partial class Types {

  3363.       /// <summary>

  3364.       /// Everything inside Experimental is subject to change and is not subject

  3365.       /// to API stability guarantees in

  3366.       /// https://www.tensorflow.org/guide/version_compat.

  3367.       /// </summary>

  3368.       public sealed partial class Experimental : pb::IMessage<Experimental> {

  3369.         private static readonly pb::MessageParser<Experimental> _parser = new pb::MessageParser<Experimental>(() => new Experimental());

  3370.         private pb::UnknownFieldSet _unknownFields;

  3371.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3372.         public static pb::MessageParser<Experimental> Parser { get { return _parser; } }

  3373. 

  3374.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3375.         public static pbr::MessageDescriptor Descriptor {

  3376.           get { return global::Tensorflow.ConfigProto.Descriptor.NestedTypes[1]; }

  3377.         }

  3378. 

  3379.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3380.         pbr::MessageDescriptor pb::IMessage.Descriptor {

  3381.           get { return Descriptor; }

  3382.         }

  3383. 

  3384.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3385.         public Experimental() {

  3386.           OnConstruction();

  3387.         }

  3388. 

  3389.         partial void OnConstruction();

  3390. 

  3391.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3392.         public Experimental(Experimental other) : this() {

  3393.           collectiveGroupLeader_ = other.collectiveGroupLeader_;

  3394.           executorType_ = other.executorType_;

  3395.           recvBufMaxChunk_ = other.recvBufMaxChunk_;

  3396.           useNumaAffinity_ = other.useNumaAffinity_;

  3397.           collectiveDeterministicSequentialExecution_ = other.collectiveDeterministicSequentialExecution_;

  3398.           collectiveNccl_ = other.collectiveNccl_;

  3399.           shareSessionStateInClusterspecPropagation_ = other.shareSessionStateInClusterspecPropagation_;

  3400.           disableThreadSpinning_ = other.disableThreadSpinning_;

  3401.           shareClusterDevicesInSession_ = other.shareClusterDevicesInSession_;

  3402.           sessionMetadata_ = other.sessionMetadata_ != null ? other.sessionMetadata_.Clone() : null;

  3403.           optimizeForStaticGraph_ = other.optimizeForStaticGraph_;

  3404.           enableMlirBridge_ = other.enableMlirBridge_;

  3405.           mlirBridgeRollout_ = other.mlirBridgeRollout_;

  3406.           enableMlirGraphOptimization_ = other.enableMlirGraphOptimization_;

  3407.           disableOutputPartitionGraphs_ = other.disableOutputPartitionGraphs_;

  3408.           xlaFusionAutotunerThresh_ = other.xlaFusionAutotunerThresh_;

  3409.           useTfrt_ = other.useTfrt_;

  3410.           coordinationService_ = other.coordinationService_;

  3411.           fetchRemoteDevicesInMultiClient_ = other.fetchRemoteDevicesInMultiClient_;

  3412.           _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  3413.         }

  3414. 

  3415.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3416.         public Experimental Clone() {

  3417.           return new Experimental(this);

  3418.         }

  3419. 

  3420.         /// <summary>Field number for the "collective_group_leader" field.</summary>

  3421.         public const int CollectiveGroupLeaderFieldNumber = 1;

  3422.         private string collectiveGroupLeader_ = "";

  3423.         /// <summary>

  3424.         /// Task name for group resolution.

  3425.         /// </summary>

  3426.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3427.         public string CollectiveGroupLeader {

  3428.           get { return collectiveGroupLeader_; }

  3429.           set {

  3430.             collectiveGroupLeader_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  3431.           }

  3432.         }

  3433. 

  3434.         /// <summary>Field number for the "executor_type" field.</summary>

  3435.         public const int ExecutorTypeFieldNumber = 3;

  3436.         private string executorType_ = "";

  3437.         /// <summary>

  3438.         /// Which executor to use, the default executor will be used

  3439.         /// if it is an empty string or "DEFAULT"

  3440.         /// </summary>

  3441.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3442.         public string ExecutorType {

  3443.           get { return executorType_; }

  3444.           set {

  3445.             executorType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  3446.           }

  3447.         }

  3448. 

  3449.         /// <summary>Field number for the "recv_buf_max_chunk" field.</summary>

  3450.         public const int RecvBufMaxChunkFieldNumber = 4;

  3451.         private int recvBufMaxChunk_;

  3452.         /// <summary>

  3453.         /// Guidance to formatting of large RecvBuf fields for transfer.

  3454.         /// Any positive value sets the max chunk size.  0 defaults to 4096.

  3455.         /// Any negative value indicates no max, i.e. one chunk only.

  3456.         /// </summary>

  3457.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3458.         public int RecvBufMaxChunk {

  3459.           get { return recvBufMaxChunk_; }

  3460.           set {

  3461.             recvBufMaxChunk_ = value;

  3462.           }

  3463.         }

  3464. 

  3465.         /// <summary>Field number for the "use_numa_affinity" field.</summary>

  3466.         public const int UseNumaAffinityFieldNumber = 5;

  3467.         private bool useNumaAffinity_;

  3468.         /// <summary>

  3469.         /// If true, and supported by the platform, the runtime will attempt to

  3470.         /// use NUMA affinity where applicable.  One consequence will be the

  3471.         /// existence of as many CPU devices as there are available NUMA nodes.

  3472.         /// </summary>

  3473.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3474.         public bool UseNumaAffinity {

  3475.           get { return useNumaAffinity_; }

  3476.           set {

  3477.             useNumaAffinity_ = value;

  3478.           }

  3479.         }

  3480. 

  3481.         /// <summary>Field number for the "collective_deterministic_sequential_execution" field.</summary>

  3482.         public const int CollectiveDeterministicSequentialExecutionFieldNumber = 6;

  3483.         private bool collectiveDeterministicSequentialExecution_;

  3484.         /// <summary>

  3485.         /// If true, make collective op execution order sequential and deterministic

  3486.         /// for potentially concurrent collective instances.

  3487.         /// </summary>

  3488.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3489.         public bool CollectiveDeterministicSequentialExecution {

  3490.           get { return collectiveDeterministicSequentialExecution_; }

  3491.           set {

  3492.             collectiveDeterministicSequentialExecution_ = value;

  3493.           }

  3494.         }

  3495. 

  3496.         /// <summary>Field number for the "collective_nccl" field.</summary>

  3497.         public const int CollectiveNcclFieldNumber = 7;

  3498.         private bool collectiveNccl_;

  3499.         /// <summary>

  3500.         /// If true, use NCCL for CollectiveOps.  This feature is highly

  3501.         /// experimental.

  3502.         /// </summary>

  3503.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3504.         public bool CollectiveNccl {

  3505.           get { return collectiveNccl_; }

  3506.           set {

  3507.             collectiveNccl_ = value;

  3508.           }

  3509.         }

  3510. 

  3511.         /// <summary>Field number for the "share_session_state_in_clusterspec_propagation" field.</summary>

  3512.         public const int ShareSessionStateInClusterspecPropagationFieldNumber = 8;

  3513.         private bool shareSessionStateInClusterspecPropagation_;

  3514.         /// <summary>

  3515.         /// In the following, session state means the value of a variable, elements

  3516.         /// in a hash table, or any other resource, accessible by worker sessions

  3517.         /// held by a TF server.

  3518.         ///

  3519.         /// When ClusterSpec propagation is enabled, the value of

  3520.         /// isolate_session_state is ignored when deciding whether to share session

  3521.         /// states in a TF server (for backwards compatibility reasons).

  3522.         /// - If share_session_state_in_clusterspec_propagation is true, the session

  3523.         /// states are shared.

  3524.         /// - If share_session_state_in_clusterspec_propagation is false, session

  3525.         /// states are isolated.

  3526.         ///

  3527.         /// When clusterspec propagation is not used, the value of

  3528.         /// share_session_state_in_clusterspec_propagation is ignored when deciding

  3529.         /// whether to share session states in a TF server.

  3530.         /// - If isolate_session_state is true, session states are isolated.

  3531.         /// - If isolate_session_state is false, session states are shared.

  3532.         ///

  3533.         /// TODO(b/129330037): Add a single API that consistently treats

  3534.         /// isolate_session_state and ClusterSpec propagation.

  3535.         /// </summary>

  3536.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3537.         public bool ShareSessionStateInClusterspecPropagation {

  3538.           get { return shareSessionStateInClusterspecPropagation_; }

  3539.           set {

  3540.             shareSessionStateInClusterspecPropagation_ = value;

  3541.           }

  3542.         }

  3543. 

  3544.         /// <summary>Field number for the "disable_thread_spinning" field.</summary>

  3545.         public const int DisableThreadSpinningFieldNumber = 9;

  3546.         private bool disableThreadSpinning_;

  3547.         /// <summary>

  3548.         /// If using a direct session, disable spinning while waiting for work in

  3549.         /// the thread pool. This may result in higher latency for completing ops,

  3550.         /// but in the case where there is a lot of spinning may result in lower

  3551.         /// CPU usage.

  3552.         /// </summary>

  3553.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3554.         public bool DisableThreadSpinning {

  3555.           get { return disableThreadSpinning_; }

  3556.           set {

  3557.             disableThreadSpinning_ = value;

  3558.           }

  3559.         }

  3560. 

  3561.         /// <summary>Field number for the "share_cluster_devices_in_session" field.</summary>

  3562.         public const int ShareClusterDevicesInSessionFieldNumber = 10;

  3563.         private bool shareClusterDevicesInSession_;

  3564.         /// <summary>

  3565.         /// This was promoted to a non-experimental API. Please use

  3566.         /// ConfigProto.share_cluster_devices_in_session instead.

  3567.         /// </summary>

  3568.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3569.         public bool ShareClusterDevicesInSession {

  3570.           get { return shareClusterDevicesInSession_; }

  3571.           set {

  3572.             shareClusterDevicesInSession_ = value;

  3573.           }

  3574.         }

  3575. 

  3576.         /// <summary>Field number for the "session_metadata" field.</summary>

  3577.         public const int SessionMetadataFieldNumber = 11;

  3578.         private global::Tensorflow.SessionMetadata sessionMetadata_;

  3579.         /// <summary>

  3580.         /// Metadata about the session.

  3581.         ///

  3582.         /// If set, this can be used by the runtime and the Ops for debugging,

  3583.         /// monitoring, etc.

  3584.         ///

  3585.         /// NOTE: This is currently used and propagated only by the direct session.

  3586.         /// </summary>

  3587.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3588.         public global::Tensorflow.SessionMetadata SessionMetadata {

  3589.           get { return sessionMetadata_; }

  3590.           set {

  3591.             sessionMetadata_ = value;

  3592.           }

  3593.         }

  3594. 

  3595.         /// <summary>Field number for the "optimize_for_static_graph" field.</summary>

  3596.         public const int OptimizeForStaticGraphFieldNumber = 12;

  3597.         private bool optimizeForStaticGraph_;

  3598.         /// <summary>

  3599.         /// If true, the session may treat the graph as being static for optimization

  3600.         /// purposes.

  3601.         ///

  3602.         /// If this option is set to true when a session is created, the full

  3603.         /// GraphDef must be passed in a single call to Session::Create(), and

  3604.         /// Session::Extend() may not be supported.

  3605.         /// </summary>

  3606.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3607.         public bool OptimizeForStaticGraph {

  3608.           get { return optimizeForStaticGraph_; }

  3609.           set {

  3610.             optimizeForStaticGraph_ = value;

  3611.           }

  3612.         }

  3613. 

  3614.         /// <summary>Field number for the "enable_mlir_bridge" field.</summary>

  3615.         public const int EnableMlirBridgeFieldNumber = 13;

  3616.         private bool enableMlirBridge_;

  3617.         /// <summary>

  3618.         /// This field will eventually be deprecated and replaced by

  3619.         /// mlir_bridge_rollout (b/166038521).

  3620.         ///

  3621.         /// Whether to enable the MLIR-based TF->XLA bridge.

  3622.         ///

  3623.         /// This is a replacement to the existing bridge, and not ready for

  3624.         /// production usage yet.

  3625.         /// If this option is set to true when a session is created, MLIR is used to

  3626.         /// perform the set of graph transformations to put the graph in a form that

  3627.         /// can be executed with delegation of some computations to an accelerator.

  3628.         /// This builds on the model of XLA where a subset of the graph is

  3629.         /// encapsulated and attached to a "compile" operation, whose result is fed

  3630.         /// to an "execute" operation. The kernel for these operations is responsible

  3631.         /// to lower the encapsulated graph to a particular device.

  3632.         /// </summary>

  3633.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3634.         public bool EnableMlirBridge {

  3635.           get { return enableMlirBridge_; }

  3636.           set {

  3637.             enableMlirBridge_ = value;

  3638.           }

  3639.         }

  3640. 

  3641.         /// <summary>Field number for the "mlir_bridge_rollout" field.</summary>

  3642.         public const int MlirBridgeRolloutFieldNumber = 17;

  3643.         private global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout mlirBridgeRollout_ = global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout.Unspecified;

  3644.         /// <summary>

  3645.         /// This field is underdevelopment, for now use enable_mlir_bridge

  3646.         /// (b/166038521).

  3647.         ///

  3648.         /// Whether to enable the MLIR-based TF->XLA bridge.

  3649.         /// </summary>

  3650.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3651.         public global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout MlirBridgeRollout {

  3652.           get { return mlirBridgeRollout_; }

  3653.           set {

  3654.             mlirBridgeRollout_ = value;

  3655.           }

  3656.         }

  3657. 

  3658.         /// <summary>Field number for the "enable_mlir_graph_optimization" field.</summary>

  3659.         public const int EnableMlirGraphOptimizationFieldNumber = 16;

  3660.         private bool enableMlirGraphOptimization_;

  3661.         /// <summary>

  3662.         /// Whether to enable the MLIR-based Graph optimizations.

  3663.         ///

  3664.         /// This will become a part of standard Tensorflow graph optimization

  3665.         /// pipeline, currently this is only used for gradual migration and testing

  3666.         /// new passes that are replacing existing optimizations in Grappler.

  3667.         /// </summary>

  3668.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3669.         public bool EnableMlirGraphOptimization {

  3670.           get { return enableMlirGraphOptimization_; }

  3671.           set {

  3672.             enableMlirGraphOptimization_ = value;

  3673.           }

  3674.         }

  3675. 

  3676.         /// <summary>Field number for the "disable_output_partition_graphs" field.</summary>

  3677.         public const int DisableOutputPartitionGraphsFieldNumber = 14;

  3678.         private bool disableOutputPartitionGraphs_;

  3679.         /// <summary>

  3680.         /// If true, the session will not store an additional copy of the graph for

  3681.         /// each subgraph.

  3682.         ///

  3683.         /// If this option is set to true when a session is created, the

  3684.         /// `RunOptions.output_partition_graphs` options must not be set.

  3685.         /// </summary>

  3686.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3687.         public bool DisableOutputPartitionGraphs {

  3688.           get { return disableOutputPartitionGraphs_; }

  3689.           set {

  3690.             disableOutputPartitionGraphs_ = value;

  3691.           }

  3692.         }

  3693. 

  3694.         /// <summary>Field number for the "xla_fusion_autotuner_thresh" field.</summary>

  3695.         public const int XlaFusionAutotunerThreshFieldNumber = 15;

  3696.         private long xlaFusionAutotunerThresh_;

  3697.         /// <summary>

  3698.         /// Minimum number of batches run through the XLA graph before XLA fusion

  3699.         /// autotuner is enabled. Default value of zero disables the autotuner.

  3700.         ///

  3701.         /// The XLA fusion autotuner can improve performance by executing a heuristic

  3702.         /// search on the compiler parameters.

  3703.         /// </summary>

  3704.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3705.         public long XlaFusionAutotunerThresh {

  3706.           get { return xlaFusionAutotunerThresh_; }

  3707.           set {

  3708.             xlaFusionAutotunerThresh_ = value;

  3709.           }

  3710.         }

  3711. 

  3712.         /// <summary>Field number for the "use_tfrt" field.</summary>

  3713.         public const int UseTfrtFieldNumber = 18;

  3714.         private bool useTfrt_;

  3715.         /// <summary>

  3716.         /// Whether runtime execution uses TFRT.

  3717.         /// </summary>

  3718.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3719.         public bool UseTfrt {

  3720.           get { return useTfrt_; }

  3721.           set {

  3722.             useTfrt_ = value;

  3723.           }

  3724.         }

  3725. 

  3726.         /// <summary>Field number for the "coordination_service" field.</summary>

  3727.         public const int CoordinationServiceFieldNumber = 19;

  3728.         private string coordinationService_ = "";

  3729.         /// <summary>

  3730.         /// Distributed coordination service to be enabled if set.

  3731.         /// Currently only effective in multi-client setup.

  3732.         /// </summary>

  3733.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3734.         public string CoordinationService {

  3735.           get { return coordinationService_; }

  3736.           set {

  3737.             coordinationService_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  3738.           }

  3739.         }

  3740. 

  3741.         /// <summary>Field number for the "fetch_remote_devices_in_multi_client" field.</summary>

  3742.         public const int FetchRemoteDevicesInMultiClientFieldNumber = 20;

  3743.         private bool fetchRemoteDevicesInMultiClient_;

  3744.         /// <summary>

  3745.         /// Whether the remote devices in the cluster should be fetched during setup

  3746.         /// of multi-client cluster. If enabled, the workers will run an extra device

  3747.         /// information exchange step during startup and the workers' EagerContexts

  3748.         /// will become aware of remote devices in the cluster as well.

  3749.         /// </summary>

  3750.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3751.         public bool FetchRemoteDevicesInMultiClient {

  3752.           get { return fetchRemoteDevicesInMultiClient_; }

  3753.           set {

  3754.             fetchRemoteDevicesInMultiClient_ = value;

  3755.           }

  3756.         }

  3757. 

  3758.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3759.         public override bool Equals(object other) {

  3760.           return Equals(other as Experimental);

  3761.         }

  3762. 

  3763.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3764.         public bool Equals(Experimental other) {

  3765.           if (ReferenceEquals(other, null)) {

  3766.             return false;

  3767.           }

  3768.           if (ReferenceEquals(other, this)) {

  3769.             return true;

  3770.           }

  3771.           if (CollectiveGroupLeader != other.CollectiveGroupLeader) return false;

  3772.           if (ExecutorType != other.ExecutorType) return false;

  3773.           if (RecvBufMaxChunk != other.RecvBufMaxChunk) return false;

  3774.           if (UseNumaAffinity != other.UseNumaAffinity) return false;

  3775.           if (CollectiveDeterministicSequentialExecution != other.CollectiveDeterministicSequentialExecution) return false;

  3776.           if (CollectiveNccl != other.CollectiveNccl) return false;

  3777.           if (ShareSessionStateInClusterspecPropagation != other.ShareSessionStateInClusterspecPropagation) return false;

  3778.           if (DisableThreadSpinning != other.DisableThreadSpinning) return false;

  3779.           if (ShareClusterDevicesInSession != other.ShareClusterDevicesInSession) return false;

  3780.           if (!object.Equals(SessionMetadata, other.SessionMetadata)) return false;

  3781.           if (OptimizeForStaticGraph != other.OptimizeForStaticGraph) return false;

  3782.           if (EnableMlirBridge != other.EnableMlirBridge) return false;

  3783.           if (MlirBridgeRollout != other.MlirBridgeRollout) return false;

  3784.           if (EnableMlirGraphOptimization != other.EnableMlirGraphOptimization) return false;

  3785.           if (DisableOutputPartitionGraphs != other.DisableOutputPartitionGraphs) return false;

  3786.           if (XlaFusionAutotunerThresh != other.XlaFusionAutotunerThresh) return false;

  3787.           if (UseTfrt != other.UseTfrt) return false;

  3788.           if (CoordinationService != other.CoordinationService) return false;

  3789.           if (FetchRemoteDevicesInMultiClient != other.FetchRemoteDevicesInMultiClient) return false;

  3790.           return Equals(_unknownFields, other._unknownFields);

  3791.         }

  3792. 

  3793.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3794.         public override int GetHashCode() {

  3795.           int hash = 1;

  3796.           if (CollectiveGroupLeader.Length != 0) hash ^= CollectiveGroupLeader.GetHashCode();

  3797.           if (ExecutorType.Length != 0) hash ^= ExecutorType.GetHashCode();

  3798.           if (RecvBufMaxChunk != 0) hash ^= RecvBufMaxChunk.GetHashCode();

  3799.           if (UseNumaAffinity != false) hash ^= UseNumaAffinity.GetHashCode();

  3800.           if (CollectiveDeterministicSequentialExecution != false) hash ^= CollectiveDeterministicSequentialExecution.GetHashCode();

  3801.           if (CollectiveNccl != false) hash ^= CollectiveNccl.GetHashCode();

  3802.           if (ShareSessionStateInClusterspecPropagation != false) hash ^= ShareSessionStateInClusterspecPropagation.GetHashCode();

  3803.           if (DisableThreadSpinning != false) hash ^= DisableThreadSpinning.GetHashCode();

  3804.           if (ShareClusterDevicesInSession != false) hash ^= ShareClusterDevicesInSession.GetHashCode();

  3805.           if (sessionMetadata_ != null) hash ^= SessionMetadata.GetHashCode();

  3806.           if (OptimizeForStaticGraph != false) hash ^= OptimizeForStaticGraph.GetHashCode();

  3807.           if (EnableMlirBridge != false) hash ^= EnableMlirBridge.GetHashCode();

  3808.           if (MlirBridgeRollout != global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout.Unspecified) hash ^= MlirBridgeRollout.GetHashCode();

  3809.           if (EnableMlirGraphOptimization != false) hash ^= EnableMlirGraphOptimization.GetHashCode();

  3810.           if (DisableOutputPartitionGraphs != false) hash ^= DisableOutputPartitionGraphs.GetHashCode();

  3811.           if (XlaFusionAutotunerThresh != 0L) hash ^= XlaFusionAutotunerThresh.GetHashCode();

  3812.           if (UseTfrt != false) hash ^= UseTfrt.GetHashCode();

  3813.           if (CoordinationService.Length != 0) hash ^= CoordinationService.GetHashCode();

  3814.           if (FetchRemoteDevicesInMultiClient != false) hash ^= FetchRemoteDevicesInMultiClient.GetHashCode();

  3815.           if (_unknownFields != null) {

  3816.             hash ^= _unknownFields.GetHashCode();

  3817.           }

  3818.           return hash;

  3819.         }

  3820. 

  3821.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3822.         public override string ToString() {

  3823.           return pb::JsonFormatter.ToDiagnosticString(this);

  3824.         }

  3825. 

  3826.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3827.         public void WriteTo(pb::CodedOutputStream output) {

  3828.           if (CollectiveGroupLeader.Length != 0) {

  3829.             output.WriteRawTag(10);

  3830.             output.WriteString(CollectiveGroupLeader);

  3831.           }

  3832.           if (ExecutorType.Length != 0) {

  3833.             output.WriteRawTag(26);

  3834.             output.WriteString(ExecutorType);

  3835.           }

  3836.           if (RecvBufMaxChunk != 0) {

  3837.             output.WriteRawTag(32);

  3838.             output.WriteInt32(RecvBufMaxChunk);

  3839.           }

  3840.           if (UseNumaAffinity != false) {

  3841.             output.WriteRawTag(40);

  3842.             output.WriteBool(UseNumaAffinity);

  3843.           }

  3844.           if (CollectiveDeterministicSequentialExecution != false) {

  3845.             output.WriteRawTag(48);

  3846.             output.WriteBool(CollectiveDeterministicSequentialExecution);

  3847.           }

  3848.           if (CollectiveNccl != false) {

  3849.             output.WriteRawTag(56);

  3850.             output.WriteBool(CollectiveNccl);

  3851.           }

  3852.           if (ShareSessionStateInClusterspecPropagation != false) {

  3853.             output.WriteRawTag(64);

  3854.             output.WriteBool(ShareSessionStateInClusterspecPropagation);

  3855.           }

  3856.           if (DisableThreadSpinning != false) {

  3857.             output.WriteRawTag(72);

  3858.             output.WriteBool(DisableThreadSpinning);

  3859.           }

  3860.           if (ShareClusterDevicesInSession != false) {

  3861.             output.WriteRawTag(80);

  3862.             output.WriteBool(ShareClusterDevicesInSession);

  3863.           }

  3864.           if (sessionMetadata_ != null) {

  3865.             output.WriteRawTag(90);

  3866.             output.WriteMessage(SessionMetadata);

  3867.           }

  3868.           if (OptimizeForStaticGraph != false) {

  3869.             output.WriteRawTag(96);

  3870.             output.WriteBool(OptimizeForStaticGraph);

  3871.           }

  3872.           if (EnableMlirBridge != false) {

  3873.             output.WriteRawTag(104);

  3874.             output.WriteBool(EnableMlirBridge);

  3875.           }

  3876.           if (DisableOutputPartitionGraphs != false) {

  3877.             output.WriteRawTag(112);

  3878.             output.WriteBool(DisableOutputPartitionGraphs);

  3879.           }

  3880.           if (XlaFusionAutotunerThresh != 0L) {

  3881.             output.WriteRawTag(120);

  3882.             output.WriteInt64(XlaFusionAutotunerThresh);

  3883.           }

  3884.           if (EnableMlirGraphOptimization != false) {

  3885.             output.WriteRawTag(128, 1);

  3886.             output.WriteBool(EnableMlirGraphOptimization);

  3887.           }

  3888.           if (MlirBridgeRollout != global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout.Unspecified) {

  3889.             output.WriteRawTag(136, 1);

  3890.             output.WriteEnum((int) MlirBridgeRollout);

  3891.           }

  3892.           if (UseTfrt != false) {

  3893.             output.WriteRawTag(144, 1);

  3894.             output.WriteBool(UseTfrt);

  3895.           }

  3896.           if (CoordinationService.Length != 0) {

  3897.             output.WriteRawTag(154, 1);

  3898.             output.WriteString(CoordinationService);

  3899.           }

  3900.           if (FetchRemoteDevicesInMultiClient != false) {

  3901.             output.WriteRawTag(160, 1);

  3902.             output.WriteBool(FetchRemoteDevicesInMultiClient);

  3903.           }

  3904.           if (_unknownFields != null) {

  3905.             _unknownFields.WriteTo(output);

  3906.           }

  3907.         }

  3908. 

  3909.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3910.         public int CalculateSize() {

  3911.           int size = 0;

  3912.           if (CollectiveGroupLeader.Length != 0) {

  3913.             size += 1 + pb::CodedOutputStream.ComputeStringSize(CollectiveGroupLeader);

  3914.           }

  3915.           if (ExecutorType.Length != 0) {

  3916.             size += 1 + pb::CodedOutputStream.ComputeStringSize(ExecutorType);

  3917.           }

  3918.           if (RecvBufMaxChunk != 0) {

  3919.             size += 1 + pb::CodedOutputStream.ComputeInt32Size(RecvBufMaxChunk);

  3920.           }

  3921.           if (UseNumaAffinity != false) {

  3922.             size += 1 + 1;

  3923.           }

  3924.           if (CollectiveDeterministicSequentialExecution != false) {

  3925.             size += 1 + 1;

  3926.           }

  3927.           if (CollectiveNccl != false) {

  3928.             size += 1 + 1;

  3929.           }

  3930.           if (ShareSessionStateInClusterspecPropagation != false) {

  3931.             size += 1 + 1;

  3932.           }

  3933.           if (DisableThreadSpinning != false) {

  3934.             size += 1 + 1;

  3935.           }

  3936.           if (ShareClusterDevicesInSession != false) {

  3937.             size += 1 + 1;

  3938.           }

  3939.           if (sessionMetadata_ != null) {

  3940.             size += 1 + pb::CodedOutputStream.ComputeMessageSize(SessionMetadata);

  3941.           }

  3942.           if (OptimizeForStaticGraph != false) {

  3943.             size += 1 + 1;

  3944.           }

  3945.           if (EnableMlirBridge != false) {

  3946.             size += 1 + 1;

  3947.           }

  3948.           if (MlirBridgeRollout != global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout.Unspecified) {

  3949.             size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) MlirBridgeRollout);

  3950.           }

  3951.           if (EnableMlirGraphOptimization != false) {

  3952.             size += 2 + 1;

  3953.           }

  3954.           if (DisableOutputPartitionGraphs != false) {

  3955.             size += 1 + 1;

  3956.           }

  3957.           if (XlaFusionAutotunerThresh != 0L) {

  3958.             size += 1 + pb::CodedOutputStream.ComputeInt64Size(XlaFusionAutotunerThresh);

  3959.           }

  3960.           if (UseTfrt != false) {

  3961.             size += 2 + 1;

  3962.           }

  3963.           if (CoordinationService.Length != 0) {

  3964.             size += 2 + pb::CodedOutputStream.ComputeStringSize(CoordinationService);

  3965.           }

  3966.           if (FetchRemoteDevicesInMultiClient != false) {

  3967.             size += 2 + 1;

  3968.           }

  3969.           if (_unknownFields != null) {

  3970.             size += _unknownFields.CalculateSize();

  3971.           }

  3972.           return size;

  3973.         }

  3974. 

  3975.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  3976.         public void MergeFrom(Experimental other) {

  3977.           if (other == null) {

  3978.             return;

  3979.           }

  3980.           if (other.CollectiveGroupLeader.Length != 0) {

  3981.             CollectiveGroupLeader = other.CollectiveGroupLeader;

  3982.           }

  3983.           if (other.ExecutorType.Length != 0) {

  3984.             ExecutorType = other.ExecutorType;

  3985.           }

  3986.           if (other.RecvBufMaxChunk != 0) {

  3987.             RecvBufMaxChunk = other.RecvBufMaxChunk;

  3988.           }

  3989.           if (other.UseNumaAffinity != false) {

  3990.             UseNumaAffinity = other.UseNumaAffinity;

  3991.           }

  3992.           if (other.CollectiveDeterministicSequentialExecution != false) {

  3993.             CollectiveDeterministicSequentialExecution = other.CollectiveDeterministicSequentialExecution;

  3994.           }

  3995.           if (other.CollectiveNccl != false) {

  3996.             CollectiveNccl = other.CollectiveNccl;

  3997.           }

  3998.           if (other.ShareSessionStateInClusterspecPropagation != false) {

  3999.             ShareSessionStateInClusterspecPropagation = other.ShareSessionStateInClusterspecPropagation;

  4000.           }

  4001.           if (other.DisableThreadSpinning != false) {

  4002.             DisableThreadSpinning = other.DisableThreadSpinning;

  4003.           }

  4004.           if (other.ShareClusterDevicesInSession != false) {

  4005.             ShareClusterDevicesInSession = other.ShareClusterDevicesInSession;

  4006.           }

  4007.           if (other.sessionMetadata_ != null) {

  4008.             if (sessionMetadata_ == null) {

  4009.               SessionMetadata = new global::Tensorflow.SessionMetadata();

  4010.             }

  4011.             SessionMetadata.MergeFrom(other.SessionMetadata);

  4012.           }

  4013.           if (other.OptimizeForStaticGraph != false) {

  4014.             OptimizeForStaticGraph = other.OptimizeForStaticGraph;

  4015.           }

  4016.           if (other.EnableMlirBridge != false) {

  4017.             EnableMlirBridge = other.EnableMlirBridge;

  4018.           }

  4019.           if (other.MlirBridgeRollout != global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout.Unspecified) {

  4020.             MlirBridgeRollout = other.MlirBridgeRollout;

  4021.           }

  4022.           if (other.EnableMlirGraphOptimization != false) {

  4023.             EnableMlirGraphOptimization = other.EnableMlirGraphOptimization;

  4024.           }

  4025.           if (other.DisableOutputPartitionGraphs != false) {

  4026.             DisableOutputPartitionGraphs = other.DisableOutputPartitionGraphs;

  4027.           }

  4028.           if (other.XlaFusionAutotunerThresh != 0L) {

  4029.             XlaFusionAutotunerThresh = other.XlaFusionAutotunerThresh;

  4030.           }

  4031.           if (other.UseTfrt != false) {

  4032.             UseTfrt = other.UseTfrt;

  4033.           }

  4034.           if (other.CoordinationService.Length != 0) {

  4035.             CoordinationService = other.CoordinationService;

  4036.           }

  4037.           if (other.FetchRemoteDevicesInMultiClient != false) {

  4038.             FetchRemoteDevicesInMultiClient = other.FetchRemoteDevicesInMultiClient;

  4039.           }

  4040.           _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  4041.         }

  4042. 

  4043.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4044.         public void MergeFrom(pb::CodedInputStream input) {

  4045.           uint tag;

  4046.           while ((tag = input.ReadTag()) != 0) {

  4047.             switch(tag) {

  4048.               default:

  4049.                 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  4050.                 break;

  4051.               case 10: {

  4052.                 CollectiveGroupLeader = input.ReadString();

  4053.                 break;

  4054.               }

  4055.               case 26: {

  4056.                 ExecutorType = input.ReadString();

  4057.                 break;

  4058.               }

  4059.               case 32: {

  4060.                 RecvBufMaxChunk = input.ReadInt32();

  4061.                 break;

  4062.               }

  4063.               case 40: {

  4064.                 UseNumaAffinity = input.ReadBool();

  4065.                 break;

  4066.               }

  4067.               case 48: {

  4068.                 CollectiveDeterministicSequentialExecution = input.ReadBool();

  4069.                 break;

  4070.               }

  4071.               case 56: {

  4072.                 CollectiveNccl = input.ReadBool();

  4073.                 break;

  4074.               }

  4075.               case 64: {

  4076.                 ShareSessionStateInClusterspecPropagation = input.ReadBool();

  4077.                 break;

  4078.               }

  4079.               case 72: {

  4080.                 DisableThreadSpinning = input.ReadBool();

  4081.                 break;

  4082.               }

  4083.               case 80: {

  4084.                 ShareClusterDevicesInSession = input.ReadBool();

  4085.                 break;

  4086.               }

  4087.               case 90: {

  4088.                 if (sessionMetadata_ == null) {

  4089.                   SessionMetadata = new global::Tensorflow.SessionMetadata();

  4090.                 }

  4091.                 input.ReadMessage(SessionMetadata);

  4092.                 break;

  4093.               }

  4094.               case 96: {

  4095.                 OptimizeForStaticGraph = input.ReadBool();

  4096.                 break;

  4097.               }

  4098.               case 104: {

  4099.                 EnableMlirBridge = input.ReadBool();

  4100.                 break;

  4101.               }

  4102.               case 112: {

  4103.                 DisableOutputPartitionGraphs = input.ReadBool();

  4104.                 break;

  4105.               }

  4106.               case 120: {

  4107.                 XlaFusionAutotunerThresh = input.ReadInt64();

  4108.                 break;

  4109.               }

  4110.               case 128: {

  4111.                 EnableMlirGraphOptimization = input.ReadBool();

  4112.                 break;

  4113.               }

  4114.               case 136: {

  4115.                 MlirBridgeRollout = (global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout) input.ReadEnum();

  4116.                 break;

  4117.               }

  4118.               case 144: {

  4119.                 UseTfrt = input.ReadBool();

  4120.                 break;

  4121.               }

  4122.               case 154: {

  4123.                 CoordinationService = input.ReadString();

  4124.                 break;

  4125.               }

  4126.               case 160: {

  4127.                 FetchRemoteDevicesInMultiClient = input.ReadBool();

  4128.                 break;

  4129.               }

  4130.             }

  4131.           }

  4132.         }

  4133. 

  4134.         #region Nested types

  4135.         /// <summary>Container for nested types declared in the Experimental message type.</summary>

  4136.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4137.         public static partial class Types {

  4138.           /// <summary>

  4139.           /// An enum that describes the state of the MLIR bridge rollout.

  4140.           /// </summary>

  4141.           public enum MlirBridgeRollout {

  4142.             /// <summary>

  4143.             /// If this field is left unspecified, the MLIR bridge may be selectively

  4144.             /// enabled on a per graph basis.

  4145.             /// </summary>

  4146.             [pbr::OriginalName("MLIR_BRIDGE_ROLLOUT_UNSPECIFIED")] Unspecified = 0,

  4147.             /// <summary>

  4148.             /// Enabling the MLIR bridge enables it for all graphs in this session.

  4149.             /// </summary>

  4150.             [pbr::OriginalName("MLIR_BRIDGE_ROLLOUT_ENABLED")] Enabled = 1,

  4151.             /// <summary>

  4152.             /// Disabling the MLIR bridge disables it for all graphs in this session.

  4153.             /// </summary>

  4154.             [pbr::OriginalName("MLIR_BRIDGE_ROLLOUT_DISABLED")] Disabled = 2,

  4155.             /// <summary>

  4156.             /// Enable the MLIR bridge on a per graph basis based on an analysis of

  4157.             /// the features used in the graph. If the features used by the graph are

  4158.             /// supported by the MLIR bridge, the MLIR bridge will be used to run the

  4159.             /// graph.

  4160.             /// </summary>

  4161.             [pbr::OriginalName("MLIR_BRIDGE_ROLLOUT_SAFE_MODE_ENABLED")] SafeModeEnabled = 3,

  4162.             /// <summary>

  4163.             /// Enable the MLIR bridge in a fallback mode on a per graph basis based

  4164.             /// on an analysis of the features used in the graph.

  4165.             /// Running the MLIR bridge in the fallback mode means that it is

  4166.             /// executed and it commits all the changes to the TF graph in case

  4167.             /// of success. And it does not in case of failures and let the old bridge

  4168.             /// to process the TF graph.

  4169.             /// </summary>

  4170.             [pbr::OriginalName("MLIR_BRIDGE_ROLLOUT_SAFE_MODE_FALLBACK_ENABLED")] SafeModeFallbackEnabled = 4,

  4171.           }

  4172. 

  4173.         }

  4174.         #endregion

  4175. 

  4176.       }

  4177. 

  4178.     }

  4179.     #endregion

  4180. 

  4181.   }

  4182. 

  4183.   /// <summary>

  4184.   /// Options for a single Run() call.

  4185.   /// </summary>

  4186.   public sealed partial class RunOptions : pb::IMessage<RunOptions> {

  4187.     private static readonly pb::MessageParser<RunOptions> _parser = new pb::MessageParser<RunOptions>(() => new RunOptions());

  4188.     private pb::UnknownFieldSet _unknownFields;

  4189.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4190.     public static pb::MessageParser<RunOptions> Parser { get { return _parser; } }

  4191. 

  4192.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4193.     public static pbr::MessageDescriptor Descriptor {

  4194.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[7]; }

  4195.     }

  4196. 

  4197.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4198.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  4199.       get { return Descriptor; }

  4200.     }

  4201. 

  4202.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4203.     public RunOptions() {

  4204.       OnConstruction();

  4205.     }

  4206. 

  4207.     partial void OnConstruction();

  4208. 

  4209.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4210.     public RunOptions(RunOptions other) : this() {

  4211.       traceLevel_ = other.traceLevel_;

  4212.       timeoutInMs_ = other.timeoutInMs_;

  4213.       interOpThreadPool_ = other.interOpThreadPool_;

  4214.       outputPartitionGraphs_ = other.outputPartitionGraphs_;

  4215.       debugOptions_ = other.debugOptions_ != null ? other.debugOptions_.Clone() : null;

  4216.       reportTensorAllocationsUponOom_ = other.reportTensorAllocationsUponOom_;

  4217.       experimental_ = other.experimental_ != null ? other.experimental_.Clone() : null;

  4218.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  4219.     }

  4220. 

  4221.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4222.     public RunOptions Clone() {

  4223.       return new RunOptions(this);

  4224.     }

  4225. 

  4226.     /// <summary>Field number for the "trace_level" field.</summary>

  4227.     public const int TraceLevelFieldNumber = 1;

  4228.     private global::Tensorflow.RunOptions.Types.TraceLevel traceLevel_ = global::Tensorflow.RunOptions.Types.TraceLevel.NoTrace;

  4229.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4230.     public global::Tensorflow.RunOptions.Types.TraceLevel TraceLevel {

  4231.       get { return traceLevel_; }

  4232.       set {

  4233.         traceLevel_ = value;

  4234.       }

  4235.     }

  4236. 

  4237.     /// <summary>Field number for the "timeout_in_ms" field.</summary>

  4238.     public const int TimeoutInMsFieldNumber = 2;

  4239.     private long timeoutInMs_;

  4240.     /// <summary>

  4241.     /// Time to wait for operation to complete in milliseconds.

  4242.     /// </summary>

  4243.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4244.     public long TimeoutInMs {

  4245.       get { return timeoutInMs_; }

  4246.       set {

  4247.         timeoutInMs_ = value;

  4248.       }

  4249.     }

  4250. 

  4251.     /// <summary>Field number for the "inter_op_thread_pool" field.</summary>

  4252.     public const int InterOpThreadPoolFieldNumber = 3;

  4253.     private int interOpThreadPool_;

  4254.     /// <summary>

  4255.     /// The thread pool to use, if session_inter_op_thread_pool is configured.

  4256.     /// To use the caller thread set this to -1 - this uses the caller thread

  4257.     /// to execute Session::Run() and thus avoids a context switch. Using the

  4258.     /// caller thread to execute Session::Run() should be done ONLY for simple

  4259.     /// graphs, where the overhead of an additional context switch is

  4260.     /// comparable with the overhead of Session::Run().

  4261.     /// </summary>

  4262.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4263.     public int InterOpThreadPool {

  4264.       get { return interOpThreadPool_; }

  4265.       set {

  4266.         interOpThreadPool_ = value;

  4267.       }

  4268.     }

  4269. 

  4270.     /// <summary>Field number for the "output_partition_graphs" field.</summary>

  4271.     public const int OutputPartitionGraphsFieldNumber = 5;

  4272.     private bool outputPartitionGraphs_;

  4273.     /// <summary>

  4274.     /// Whether the partition graph(s) executed by the executor(s) should be

  4275.     /// outputted via RunMetadata.

  4276.     /// </summary>

  4277.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4278.     public bool OutputPartitionGraphs {

  4279.       get { return outputPartitionGraphs_; }

  4280.       set {

  4281.         outputPartitionGraphs_ = value;

  4282.       }

  4283.     }

  4284. 

  4285.     /// <summary>Field number for the "debug_options" field.</summary>

  4286.     public const int DebugOptionsFieldNumber = 6;

  4287.     private global::Tensorflow.DebugOptions debugOptions_;

  4288.     /// <summary>

  4289.     /// EXPERIMENTAL.  Options used to initialize DebuggerState, if enabled.

  4290.     /// </summary>

  4291.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4292.     public global::Tensorflow.DebugOptions DebugOptions {

  4293.       get { return debugOptions_; }

  4294.       set {

  4295.         debugOptions_ = value;

  4296.       }

  4297.     }

  4298. 

  4299.     /// <summary>Field number for the "report_tensor_allocations_upon_oom" field.</summary>

  4300.     public const int ReportTensorAllocationsUponOomFieldNumber = 7;

  4301.     private bool reportTensorAllocationsUponOom_;

  4302.     /// <summary>

  4303.     /// When enabled, causes tensor allocation information to be included in

  4304.     /// the error message when the Run() call fails because the allocator ran

  4305.     /// out of memory (OOM).

  4306.     ///

  4307.     /// Enabling this option can slow down the Run() call.

  4308.     /// </summary>

  4309.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4310.     public bool ReportTensorAllocationsUponOom {

  4311.       get { return reportTensorAllocationsUponOom_; }

  4312.       set {

  4313.         reportTensorAllocationsUponOom_ = value;

  4314.       }

  4315.     }

  4316. 

  4317.     /// <summary>Field number for the "experimental" field.</summary>

  4318.     public const int ExperimentalFieldNumber = 8;

  4319.     private global::Tensorflow.RunOptions.Types.Experimental experimental_;

  4320.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4321.     public global::Tensorflow.RunOptions.Types.Experimental Experimental {

  4322.       get { return experimental_; }

  4323.       set {

  4324.         experimental_ = value;

  4325.       }

  4326.     }

  4327. 

  4328.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4329.     public override bool Equals(object other) {

  4330.       return Equals(other as RunOptions);

  4331.     }

  4332. 

  4333.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4334.     public bool Equals(RunOptions other) {

  4335.       if (ReferenceEquals(other, null)) {

  4336.         return false;

  4337.       }

  4338.       if (ReferenceEquals(other, this)) {

  4339.         return true;

  4340.       }

  4341.       if (TraceLevel != other.TraceLevel) return false;

  4342.       if (TimeoutInMs != other.TimeoutInMs) return false;

  4343.       if (InterOpThreadPool != other.InterOpThreadPool) return false;

  4344.       if (OutputPartitionGraphs != other.OutputPartitionGraphs) return false;

  4345.       if (!object.Equals(DebugOptions, other.DebugOptions)) return false;

  4346.       if (ReportTensorAllocationsUponOom != other.ReportTensorAllocationsUponOom) return false;

  4347.       if (!object.Equals(Experimental, other.Experimental)) return false;

  4348.       return Equals(_unknownFields, other._unknownFields);

  4349.     }

  4350. 

  4351.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4352.     public override int GetHashCode() {

  4353.       int hash = 1;

  4354.       if (TraceLevel != global::Tensorflow.RunOptions.Types.TraceLevel.NoTrace) hash ^= TraceLevel.GetHashCode();

  4355.       if (TimeoutInMs != 0L) hash ^= TimeoutInMs.GetHashCode();

  4356.       if (InterOpThreadPool != 0) hash ^= InterOpThreadPool.GetHashCode();

  4357.       if (OutputPartitionGraphs != false) hash ^= OutputPartitionGraphs.GetHashCode();

  4358.       if (debugOptions_ != null) hash ^= DebugOptions.GetHashCode();

  4359.       if (ReportTensorAllocationsUponOom != false) hash ^= ReportTensorAllocationsUponOom.GetHashCode();

  4360.       if (experimental_ != null) hash ^= Experimental.GetHashCode();

  4361.       if (_unknownFields != null) {

  4362.         hash ^= _unknownFields.GetHashCode();

  4363.       }

  4364.       return hash;

  4365.     }

  4366. 

  4367.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4368.     public override string ToString() {

  4369.       return pb::JsonFormatter.ToDiagnosticString(this);

  4370.     }

  4371. 

  4372.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4373.     public void WriteTo(pb::CodedOutputStream output) {

  4374.       if (TraceLevel != global::Tensorflow.RunOptions.Types.TraceLevel.NoTrace) {

  4375.         output.WriteRawTag(8);

  4376.         output.WriteEnum((int) TraceLevel);

  4377.       }

  4378.       if (TimeoutInMs != 0L) {

  4379.         output.WriteRawTag(16);

  4380.         output.WriteInt64(TimeoutInMs);

  4381.       }

  4382.       if (InterOpThreadPool != 0) {

  4383.         output.WriteRawTag(24);

  4384.         output.WriteInt32(InterOpThreadPool);

  4385.       }

  4386.       if (OutputPartitionGraphs != false) {

  4387.         output.WriteRawTag(40);

  4388.         output.WriteBool(OutputPartitionGraphs);

  4389.       }

  4390.       if (debugOptions_ != null) {

  4391.         output.WriteRawTag(50);

  4392.         output.WriteMessage(DebugOptions);

  4393.       }

  4394.       if (ReportTensorAllocationsUponOom != false) {

  4395.         output.WriteRawTag(56);

  4396.         output.WriteBool(ReportTensorAllocationsUponOom);

  4397.       }

  4398.       if (experimental_ != null) {

  4399.         output.WriteRawTag(66);

  4400.         output.WriteMessage(Experimental);

  4401.       }

  4402.       if (_unknownFields != null) {

  4403.         _unknownFields.WriteTo(output);

  4404.       }

  4405.     }

  4406. 

  4407.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4408.     public int CalculateSize() {

  4409.       int size = 0;

  4410.       if (TraceLevel != global::Tensorflow.RunOptions.Types.TraceLevel.NoTrace) {

  4411.         size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) TraceLevel);

  4412.       }

  4413.       if (TimeoutInMs != 0L) {

  4414.         size += 1 + pb::CodedOutputStream.ComputeInt64Size(TimeoutInMs);

  4415.       }

  4416.       if (InterOpThreadPool != 0) {

  4417.         size += 1 + pb::CodedOutputStream.ComputeInt32Size(InterOpThreadPool);

  4418.       }

  4419.       if (OutputPartitionGraphs != false) {

  4420.         size += 1 + 1;

  4421.       }

  4422.       if (debugOptions_ != null) {

  4423.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(DebugOptions);

  4424.       }

  4425.       if (ReportTensorAllocationsUponOom != false) {

  4426.         size += 1 + 1;

  4427.       }

  4428.       if (experimental_ != null) {

  4429.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(Experimental);

  4430.       }

  4431.       if (_unknownFields != null) {

  4432.         size += _unknownFields.CalculateSize();

  4433.       }

  4434.       return size;

  4435.     }

  4436. 

  4437.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4438.     public void MergeFrom(RunOptions other) {

  4439.       if (other == null) {

  4440.         return;

  4441.       }

  4442.       if (other.TraceLevel != global::Tensorflow.RunOptions.Types.TraceLevel.NoTrace) {

  4443.         TraceLevel = other.TraceLevel;

  4444.       }

  4445.       if (other.TimeoutInMs != 0L) {

  4446.         TimeoutInMs = other.TimeoutInMs;

  4447.       }

  4448.       if (other.InterOpThreadPool != 0) {

  4449.         InterOpThreadPool = other.InterOpThreadPool;

  4450.       }

  4451.       if (other.OutputPartitionGraphs != false) {

  4452.         OutputPartitionGraphs = other.OutputPartitionGraphs;

  4453.       }

  4454.       if (other.debugOptions_ != null) {

  4455.         if (debugOptions_ == null) {

  4456.           DebugOptions = new global::Tensorflow.DebugOptions();

  4457.         }

  4458.         DebugOptions.MergeFrom(other.DebugOptions);

  4459.       }

  4460.       if (other.ReportTensorAllocationsUponOom != false) {

  4461.         ReportTensorAllocationsUponOom = other.ReportTensorAllocationsUponOom;

  4462.       }

  4463.       if (other.experimental_ != null) {

  4464.         if (experimental_ == null) {

  4465.           Experimental = new global::Tensorflow.RunOptions.Types.Experimental();

  4466.         }

  4467.         Experimental.MergeFrom(other.Experimental);

  4468.       }

  4469.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  4470.     }

  4471. 

  4472.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4473.     public void MergeFrom(pb::CodedInputStream input) {

  4474.       uint tag;

  4475.       while ((tag = input.ReadTag()) != 0) {

  4476.         switch(tag) {

  4477.           default:

  4478.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  4479.             break;

  4480.           case 8: {

  4481.             TraceLevel = (global::Tensorflow.RunOptions.Types.TraceLevel) input.ReadEnum();

  4482.             break;

  4483.           }

  4484.           case 16: {

  4485.             TimeoutInMs = input.ReadInt64();

  4486.             break;

  4487.           }

  4488.           case 24: {

  4489.             InterOpThreadPool = input.ReadInt32();

  4490.             break;

  4491.           }

  4492.           case 40: {

  4493.             OutputPartitionGraphs = input.ReadBool();

  4494.             break;

  4495.           }

  4496.           case 50: {

  4497.             if (debugOptions_ == null) {

  4498.               DebugOptions = new global::Tensorflow.DebugOptions();

  4499.             }

  4500.             input.ReadMessage(DebugOptions);

  4501.             break;

  4502.           }

  4503.           case 56: {

  4504.             ReportTensorAllocationsUponOom = input.ReadBool();

  4505.             break;

  4506.           }

  4507.           case 66: {

  4508.             if (experimental_ == null) {

  4509.               Experimental = new global::Tensorflow.RunOptions.Types.Experimental();

  4510.             }

  4511.             input.ReadMessage(Experimental);

  4512.             break;

  4513.           }

  4514.         }

  4515.       }

  4516.     }

  4517. 

  4518.     #region Nested types

  4519.     /// <summary>Container for nested types declared in the RunOptions message type.</summary>

  4520.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4521.     public static partial class Types {

  4522.       /// <summary>

  4523.       /// TODO(pbar) Turn this into a TraceOptions proto which allows

  4524.       /// tracing to be controlled in a more orthogonal manner?

  4525.       /// </summary>

  4526.       public enum TraceLevel {

  4527.         [pbr::OriginalName("NO_TRACE")] NoTrace = 0,

  4528.         [pbr::OriginalName("SOFTWARE_TRACE")] SoftwareTrace = 1,

  4529.         [pbr::OriginalName("HARDWARE_TRACE")] HardwareTrace = 2,

  4530.         [pbr::OriginalName("FULL_TRACE")] FullTrace = 3,

  4531.       }

  4532. 

  4533.       /// <summary>

  4534.       /// Everything inside Experimental is subject to change and is not subject

  4535.       /// to API stability guarantees in

  4536.       /// https://www.tensorflow.org/guide/version_compat.

  4537.       /// </summary>

  4538.       public sealed partial class Experimental : pb::IMessage<Experimental> {

  4539.         private static readonly pb::MessageParser<Experimental> _parser = new pb::MessageParser<Experimental>(() => new Experimental());

  4540.         private pb::UnknownFieldSet _unknownFields;

  4541.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4542.         public static pb::MessageParser<Experimental> Parser { get { return _parser; } }

  4543. 

  4544.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4545.         public static pbr::MessageDescriptor Descriptor {

  4546.           get { return global::Tensorflow.RunOptions.Descriptor.NestedTypes[0]; }

  4547.         }

  4548. 

  4549.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4550.         pbr::MessageDescriptor pb::IMessage.Descriptor {

  4551.           get { return Descriptor; }

  4552.         }

  4553. 

  4554.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4555.         public Experimental() {

  4556.           OnConstruction();

  4557.         }

  4558. 

  4559.         partial void OnConstruction();

  4560. 

  4561.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4562.         public Experimental(Experimental other) : this() {

  4563.           collectiveGraphKey_ = other.collectiveGraphKey_;

  4564.           useRunHandlerPool_ = other.useRunHandlerPool_;

  4565.           runHandlerPoolOptions_ = other.runHandlerPoolOptions_ != null ? other.runHandlerPoolOptions_.Clone() : null;

  4566.           _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  4567.         }

  4568. 

  4569.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4570.         public Experimental Clone() {

  4571.           return new Experimental(this);

  4572.         }

  4573. 

  4574.         /// <summary>Field number for the "collective_graph_key" field.</summary>

  4575.         public const int CollectiveGraphKeyFieldNumber = 1;

  4576.         private long collectiveGraphKey_;

  4577.         /// <summary>

  4578.         /// If non-zero, declares that this graph is going to use collective

  4579.         /// ops and must synchronize step_ids with any other graph with this

  4580.         /// same group_key value (in a distributed computation where tasks

  4581.         /// run disjoint graphs).

  4582.         /// </summary>

  4583.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4584.         public long CollectiveGraphKey {

  4585.           get { return collectiveGraphKey_; }

  4586.           set {

  4587.             collectiveGraphKey_ = value;

  4588.           }

  4589.         }

  4590. 

  4591.         /// <summary>Field number for the "use_run_handler_pool" field.</summary>

  4592.         public const int UseRunHandlerPoolFieldNumber = 2;

  4593.         private bool useRunHandlerPool_;

  4594.         /// <summary>

  4595.         /// If true, then operations (using the inter-op pool) across all

  4596.         /// session::run() calls will be centrally scheduled, optimizing for (median

  4597.         /// and tail) latency.

  4598.         /// Consider using this option for CPU-bound workloads like inference.

  4599.         /// </summary>

  4600.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4601.         public bool UseRunHandlerPool {

  4602.           get { return useRunHandlerPool_; }

  4603.           set {

  4604.             useRunHandlerPool_ = value;

  4605.           }

  4606.         }

  4607. 

  4608.         /// <summary>Field number for the "run_handler_pool_options" field.</summary>

  4609.         public const int RunHandlerPoolOptionsFieldNumber = 3;

  4610.         private global::Tensorflow.RunOptions.Types.Experimental.Types.RunHandlerPoolOptions runHandlerPoolOptions_;

  4611.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4612.         public global::Tensorflow.RunOptions.Types.Experimental.Types.RunHandlerPoolOptions RunHandlerPoolOptions {

  4613.           get { return runHandlerPoolOptions_; }

  4614.           set {

  4615.             runHandlerPoolOptions_ = value;

  4616.           }

  4617.         }

  4618. 

  4619.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4620.         public override bool Equals(object other) {

  4621.           return Equals(other as Experimental);

  4622.         }

  4623. 

  4624.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4625.         public bool Equals(Experimental other) {

  4626.           if (ReferenceEquals(other, null)) {

  4627.             return false;

  4628.           }

  4629.           if (ReferenceEquals(other, this)) {

  4630.             return true;

  4631.           }

  4632.           if (CollectiveGraphKey != other.CollectiveGraphKey) return false;

  4633.           if (UseRunHandlerPool != other.UseRunHandlerPool) return false;

  4634.           if (!object.Equals(RunHandlerPoolOptions, other.RunHandlerPoolOptions)) return false;

  4635.           return Equals(_unknownFields, other._unknownFields);

  4636.         }

  4637. 

  4638.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4639.         public override int GetHashCode() {

  4640.           int hash = 1;

  4641.           if (CollectiveGraphKey != 0L) hash ^= CollectiveGraphKey.GetHashCode();

  4642.           if (UseRunHandlerPool != false) hash ^= UseRunHandlerPool.GetHashCode();

  4643.           if (runHandlerPoolOptions_ != null) hash ^= RunHandlerPoolOptions.GetHashCode();

  4644.           if (_unknownFields != null) {

  4645.             hash ^= _unknownFields.GetHashCode();

  4646.           }

  4647.           return hash;

  4648.         }

  4649. 

  4650.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4651.         public override string ToString() {

  4652.           return pb::JsonFormatter.ToDiagnosticString(this);

  4653.         }

  4654. 

  4655.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4656.         public void WriteTo(pb::CodedOutputStream output) {

  4657.           if (CollectiveGraphKey != 0L) {

  4658.             output.WriteRawTag(8);

  4659.             output.WriteInt64(CollectiveGraphKey);

  4660.           }

  4661.           if (UseRunHandlerPool != false) {

  4662.             output.WriteRawTag(16);

  4663.             output.WriteBool(UseRunHandlerPool);

  4664.           }

  4665.           if (runHandlerPoolOptions_ != null) {

  4666.             output.WriteRawTag(26);

  4667.             output.WriteMessage(RunHandlerPoolOptions);

  4668.           }

  4669.           if (_unknownFields != null) {

  4670.             _unknownFields.WriteTo(output);

  4671.           }

  4672.         }

  4673. 

  4674.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4675.         public int CalculateSize() {

  4676.           int size = 0;

  4677.           if (CollectiveGraphKey != 0L) {

  4678.             size += 1 + pb::CodedOutputStream.ComputeInt64Size(CollectiveGraphKey);

  4679.           }

  4680.           if (UseRunHandlerPool != false) {

  4681.             size += 1 + 1;

  4682.           }

  4683.           if (runHandlerPoolOptions_ != null) {

  4684.             size += 1 + pb::CodedOutputStream.ComputeMessageSize(RunHandlerPoolOptions);

  4685.           }

  4686.           if (_unknownFields != null) {

  4687.             size += _unknownFields.CalculateSize();

  4688.           }

  4689.           return size;

  4690.         }

  4691. 

  4692.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4693.         public void MergeFrom(Experimental other) {

  4694.           if (other == null) {

  4695.             return;

  4696.           }

  4697.           if (other.CollectiveGraphKey != 0L) {

  4698.             CollectiveGraphKey = other.CollectiveGraphKey;

  4699.           }

  4700.           if (other.UseRunHandlerPool != false) {

  4701.             UseRunHandlerPool = other.UseRunHandlerPool;

  4702.           }

  4703.           if (other.runHandlerPoolOptions_ != null) {

  4704.             if (runHandlerPoolOptions_ == null) {

  4705.               RunHandlerPoolOptions = new global::Tensorflow.RunOptions.Types.Experimental.Types.RunHandlerPoolOptions();

  4706.             }

  4707.             RunHandlerPoolOptions.MergeFrom(other.RunHandlerPoolOptions);

  4708.           }

  4709.           _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  4710.         }

  4711. 

  4712.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4713.         public void MergeFrom(pb::CodedInputStream input) {

  4714.           uint tag;

  4715.           while ((tag = input.ReadTag()) != 0) {

  4716.             switch(tag) {

  4717.               default:

  4718.                 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  4719.                 break;

  4720.               case 8: {

  4721.                 CollectiveGraphKey = input.ReadInt64();

  4722.                 break;

  4723.               }

  4724.               case 16: {

  4725.                 UseRunHandlerPool = input.ReadBool();

  4726.                 break;

  4727.               }

  4728.               case 26: {

  4729.                 if (runHandlerPoolOptions_ == null) {

  4730.                   RunHandlerPoolOptions = new global::Tensorflow.RunOptions.Types.Experimental.Types.RunHandlerPoolOptions();

  4731.                 }

  4732.                 input.ReadMessage(RunHandlerPoolOptions);

  4733.                 break;

  4734.               }

  4735.             }

  4736.           }

  4737.         }

  4738. 

  4739.         #region Nested types

  4740.         /// <summary>Container for nested types declared in the Experimental message type.</summary>

  4741.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4742.         public static partial class Types {

  4743.           /// <summary>

  4744.           /// Options for run handler thread pool.

  4745.           /// </summary>

  4746.           public sealed partial class RunHandlerPoolOptions : pb::IMessage<RunHandlerPoolOptions> {

  4747.             private static readonly pb::MessageParser<RunHandlerPoolOptions> _parser = new pb::MessageParser<RunHandlerPoolOptions>(() => new RunHandlerPoolOptions());

  4748.             private pb::UnknownFieldSet _unknownFields;

  4749.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4750.             public static pb::MessageParser<RunHandlerPoolOptions> Parser { get { return _parser; } }

  4751. 

  4752.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4753.             public static pbr::MessageDescriptor Descriptor {

  4754.               get { return global::Tensorflow.RunOptions.Types.Experimental.Descriptor.NestedTypes[0]; }

  4755.             }

  4756. 

  4757.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4758.             pbr::MessageDescriptor pb::IMessage.Descriptor {

  4759.               get { return Descriptor; }

  4760.             }

  4761. 

  4762.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4763.             public RunHandlerPoolOptions() {

  4764.               OnConstruction();

  4765.             }

  4766. 

  4767.             partial void OnConstruction();

  4768. 

  4769.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4770.             public RunHandlerPoolOptions(RunHandlerPoolOptions other) : this() {

  4771.               priority_ = other.priority_;

  4772.               _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  4773.             }

  4774. 

  4775.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4776.             public RunHandlerPoolOptions Clone() {

  4777.               return new RunHandlerPoolOptions(this);

  4778.             }

  4779. 

  4780.             /// <summary>Field number for the "priority" field.</summary>

  4781.             public const int PriorityFieldNumber = 1;

  4782.             private long priority_;

  4783.             /// <summary>

  4784.             /// Priority of the request. The run handler thread pool will schedule ops

  4785.             /// based on the priority number. The larger number means higher priority.

  4786.             /// </summary>

  4787.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4788.             public long Priority {

  4789.               get { return priority_; }

  4790.               set {

  4791.                 priority_ = value;

  4792.               }

  4793.             }

  4794. 

  4795.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4796.             public override bool Equals(object other) {

  4797.               return Equals(other as RunHandlerPoolOptions);

  4798.             }

  4799. 

  4800.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4801.             public bool Equals(RunHandlerPoolOptions other) {

  4802.               if (ReferenceEquals(other, null)) {

  4803.                 return false;

  4804.               }

  4805.               if (ReferenceEquals(other, this)) {

  4806.                 return true;

  4807.               }

  4808.               if (Priority != other.Priority) return false;

  4809.               return Equals(_unknownFields, other._unknownFields);

  4810.             }

  4811. 

  4812.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4813.             public override int GetHashCode() {

  4814.               int hash = 1;

  4815.               if (Priority != 0L) hash ^= Priority.GetHashCode();

  4816.               if (_unknownFields != null) {

  4817.                 hash ^= _unknownFields.GetHashCode();

  4818.               }

  4819.               return hash;

  4820.             }

  4821. 

  4822.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4823.             public override string ToString() {

  4824.               return pb::JsonFormatter.ToDiagnosticString(this);

  4825.             }

  4826. 

  4827.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4828.             public void WriteTo(pb::CodedOutputStream output) {

  4829.               if (Priority != 0L) {

  4830.                 output.WriteRawTag(8);

  4831.                 output.WriteInt64(Priority);

  4832.               }

  4833.               if (_unknownFields != null) {

  4834.                 _unknownFields.WriteTo(output);

  4835.               }

  4836.             }

  4837. 

  4838.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4839.             public int CalculateSize() {

  4840.               int size = 0;

  4841.               if (Priority != 0L) {

  4842.                 size += 1 + pb::CodedOutputStream.ComputeInt64Size(Priority);

  4843.               }

  4844.               if (_unknownFields != null) {

  4845.                 size += _unknownFields.CalculateSize();

  4846.               }

  4847.               return size;

  4848.             }

  4849. 

  4850.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4851.             public void MergeFrom(RunHandlerPoolOptions other) {

  4852.               if (other == null) {

  4853.                 return;

  4854.               }

  4855.               if (other.Priority != 0L) {

  4856.                 Priority = other.Priority;

  4857.               }

  4858.               _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  4859.             }

  4860. 

  4861.             [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4862.             public void MergeFrom(pb::CodedInputStream input) {

  4863.               uint tag;

  4864.               while ((tag = input.ReadTag()) != 0) {

  4865.                 switch(tag) {

  4866.                   default:

  4867.                     _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  4868.                     break;

  4869.                   case 8: {

  4870.                     Priority = input.ReadInt64();

  4871.                     break;

  4872.                   }

  4873.                 }

  4874.               }

  4875.             }

  4876. 

  4877.           }

  4878. 

  4879.         }

  4880.         #endregion

  4881. 

  4882.       }

  4883. 

  4884.     }

  4885.     #endregion

  4886. 

  4887.   }

  4888. 

  4889.   /// <summary>

  4890.   /// Metadata output (i.e., non-Tensor) for a single Run() call.

  4891.   /// </summary>

  4892.   public sealed partial class RunMetadata : pb::IMessage<RunMetadata> {

  4893.     private static readonly pb::MessageParser<RunMetadata> _parser = new pb::MessageParser<RunMetadata>(() => new RunMetadata());

  4894.     private pb::UnknownFieldSet _unknownFields;

  4895.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4896.     public static pb::MessageParser<RunMetadata> Parser { get { return _parser; } }

  4897. 

  4898.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4899.     public static pbr::MessageDescriptor Descriptor {

  4900.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[8]; }

  4901.     }

  4902. 

  4903.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4904.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  4905.       get { return Descriptor; }

  4906.     }

  4907. 

  4908.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4909.     public RunMetadata() {

  4910.       OnConstruction();

  4911.     }

  4912. 

  4913.     partial void OnConstruction();

  4914. 

  4915.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4916.     public RunMetadata(RunMetadata other) : this() {

  4917.       stepStats_ = other.stepStats_ != null ? other.stepStats_.Clone() : null;

  4918.       costGraph_ = other.costGraph_ != null ? other.costGraph_.Clone() : null;

  4919.       partitionGraphs_ = other.partitionGraphs_.Clone();

  4920.       functionGraphs_ = other.functionGraphs_.Clone();

  4921.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  4922.     }

  4923. 

  4924.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4925.     public RunMetadata Clone() {

  4926.       return new RunMetadata(this);

  4927.     }

  4928. 

  4929.     /// <summary>Field number for the "step_stats" field.</summary>

  4930.     public const int StepStatsFieldNumber = 1;

  4931.     private global::Tensorflow.StepStats stepStats_;

  4932.     /// <summary>

  4933.     /// Statistics traced for this step. Populated if tracing is turned on via the

  4934.     /// "RunOptions" proto.

  4935.     /// EXPERIMENTAL: The format and set of events may change in future versions.

  4936.     /// </summary>

  4937.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4938.     public global::Tensorflow.StepStats StepStats {

  4939.       get { return stepStats_; }

  4940.       set {

  4941.         stepStats_ = value;

  4942.       }

  4943.     }

  4944. 

  4945.     /// <summary>Field number for the "cost_graph" field.</summary>

  4946.     public const int CostGraphFieldNumber = 2;

  4947.     private global::Tensorflow.CostGraphDef costGraph_;

  4948.     /// <summary>

  4949.     /// The cost graph for the computation defined by the run call.

  4950.     /// </summary>

  4951.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4952.     public global::Tensorflow.CostGraphDef CostGraph {

  4953.       get { return costGraph_; }

  4954.       set {

  4955.         costGraph_ = value;

  4956.       }

  4957.     }

  4958. 

  4959.     /// <summary>Field number for the "partition_graphs" field.</summary>

  4960.     public const int PartitionGraphsFieldNumber = 3;

  4961.     private static readonly pb::FieldCodec<global::Tensorflow.GraphDef> _repeated_partitionGraphs_codec

  4962.         = pb::FieldCodec.ForMessage(26, global::Tensorflow.GraphDef.Parser);

  4963.     private readonly pbc::RepeatedField<global::Tensorflow.GraphDef> partitionGraphs_ = new pbc::RepeatedField<global::Tensorflow.GraphDef>();

  4964.     /// <summary>

  4965.     /// Graphs of the partitions executed by executors.

  4966.     /// </summary>

  4967.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4968.     public pbc::RepeatedField<global::Tensorflow.GraphDef> PartitionGraphs {

  4969.       get { return partitionGraphs_; }

  4970.     }

  4971. 

  4972.     /// <summary>Field number for the "function_graphs" field.</summary>

  4973.     public const int FunctionGraphsFieldNumber = 4;

  4974.     private static readonly pb::FieldCodec<global::Tensorflow.RunMetadata.Types.FunctionGraphs> _repeated_functionGraphs_codec

  4975.         = pb::FieldCodec.ForMessage(34, global::Tensorflow.RunMetadata.Types.FunctionGraphs.Parser);

  4976.     private readonly pbc::RepeatedField<global::Tensorflow.RunMetadata.Types.FunctionGraphs> functionGraphs_ = new pbc::RepeatedField<global::Tensorflow.RunMetadata.Types.FunctionGraphs>();

  4977.     /// <summary>

  4978.     /// This is only populated for graphs that are run as functions in TensorFlow

  4979.     /// V2. There will be an entry below for each function that is traced.

  4980.     /// The main use cases of the post_optimization_graph and the partition_graphs

  4981.     /// is to give the caller insight into the graphs that were actually run by the

  4982.     /// runtime. Additional information (such as those in step_stats) will match

  4983.     /// these graphs.

  4984.     /// We also include the pre_optimization_graph since it is usually easier to

  4985.     /// read, and is helpful in situations where the caller wants to get a high

  4986.     /// level idea of what the built graph looks like (since the various graph

  4987.     /// optimization passes might change the structure of the graph significantly).

  4988.     /// </summary>

  4989.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4990.     public pbc::RepeatedField<global::Tensorflow.RunMetadata.Types.FunctionGraphs> FunctionGraphs {

  4991.       get { return functionGraphs_; }

  4992.     }

  4993. 

  4994.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  4995.     public override bool Equals(object other) {

  4996.       return Equals(other as RunMetadata);

  4997.     }

  4998. 

  4999.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5000.     public bool Equals(RunMetadata other) {

  5001.       if (ReferenceEquals(other, null)) {

  5002.         return false;

  5003.       }

  5004.       if (ReferenceEquals(other, this)) {

  5005.         return true;

  5006.       }

  5007.       if (!object.Equals(StepStats, other.StepStats)) return false;

  5008.       if (!object.Equals(CostGraph, other.CostGraph)) return false;

  5009.       if(!partitionGraphs_.Equals(other.partitionGraphs_)) return false;

  5010.       if(!functionGraphs_.Equals(other.functionGraphs_)) return false;

  5011.       return Equals(_unknownFields, other._unknownFields);

  5012.     }

  5013. 

  5014.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5015.     public override int GetHashCode() {

  5016.       int hash = 1;

  5017.       if (stepStats_ != null) hash ^= StepStats.GetHashCode();

  5018.       if (costGraph_ != null) hash ^= CostGraph.GetHashCode();

  5019.       hash ^= partitionGraphs_.GetHashCode();

  5020.       hash ^= functionGraphs_.GetHashCode();

  5021.       if (_unknownFields != null) {

  5022.         hash ^= _unknownFields.GetHashCode();

  5023.       }

  5024.       return hash;

  5025.     }

  5026. 

  5027.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5028.     public override string ToString() {

  5029.       return pb::JsonFormatter.ToDiagnosticString(this);

  5030.     }

  5031. 

  5032.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5033.     public void WriteTo(pb::CodedOutputStream output) {

  5034.       if (stepStats_ != null) {

  5035.         output.WriteRawTag(10);

  5036.         output.WriteMessage(StepStats);

  5037.       }

  5038.       if (costGraph_ != null) {

  5039.         output.WriteRawTag(18);

  5040.         output.WriteMessage(CostGraph);

  5041.       }

  5042.       partitionGraphs_.WriteTo(output, _repeated_partitionGraphs_codec);

  5043.       functionGraphs_.WriteTo(output, _repeated_functionGraphs_codec);

  5044.       if (_unknownFields != null) {

  5045.         _unknownFields.WriteTo(output);

  5046.       }

  5047.     }

  5048. 

  5049.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5050.     public int CalculateSize() {

  5051.       int size = 0;

  5052.       if (stepStats_ != null) {

  5053.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(StepStats);

  5054.       }

  5055.       if (costGraph_ != null) {

  5056.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(CostGraph);

  5057.       }

  5058.       size += partitionGraphs_.CalculateSize(_repeated_partitionGraphs_codec);

  5059.       size += functionGraphs_.CalculateSize(_repeated_functionGraphs_codec);

  5060.       if (_unknownFields != null) {

  5061.         size += _unknownFields.CalculateSize();

  5062.       }

  5063.       return size;

  5064.     }

  5065. 

  5066.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5067.     public void MergeFrom(RunMetadata other) {

  5068.       if (other == null) {

  5069.         return;

  5070.       }

  5071.       if (other.stepStats_ != null) {

  5072.         if (stepStats_ == null) {

  5073.           StepStats = new global::Tensorflow.StepStats();

  5074.         }

  5075.         StepStats.MergeFrom(other.StepStats);

  5076.       }

  5077.       if (other.costGraph_ != null) {

  5078.         if (costGraph_ == null) {

  5079.           CostGraph = new global::Tensorflow.CostGraphDef();

  5080.         }

  5081.         CostGraph.MergeFrom(other.CostGraph);

  5082.       }

  5083.       partitionGraphs_.Add(other.partitionGraphs_);

  5084.       functionGraphs_.Add(other.functionGraphs_);

  5085.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  5086.     }

  5087. 

  5088.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5089.     public void MergeFrom(pb::CodedInputStream input) {

  5090.       uint tag;

  5091.       while ((tag = input.ReadTag()) != 0) {

  5092.         switch(tag) {

  5093.           default:

  5094.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  5095.             break;

  5096.           case 10: {

  5097.             if (stepStats_ == null) {

  5098.               StepStats = new global::Tensorflow.StepStats();

  5099.             }

  5100.             input.ReadMessage(StepStats);

  5101.             break;

  5102.           }

  5103.           case 18: {

  5104.             if (costGraph_ == null) {

  5105.               CostGraph = new global::Tensorflow.CostGraphDef();

  5106.             }

  5107.             input.ReadMessage(CostGraph);

  5108.             break;

  5109.           }

  5110.           case 26: {

  5111.             partitionGraphs_.AddEntriesFrom(input, _repeated_partitionGraphs_codec);

  5112.             break;

  5113.           }

  5114.           case 34: {

  5115.             functionGraphs_.AddEntriesFrom(input, _repeated_functionGraphs_codec);

  5116.             break;

  5117.           }

  5118.         }

  5119.       }

  5120.     }

  5121. 

  5122.     #region Nested types

  5123.     /// <summary>Container for nested types declared in the RunMetadata message type.</summary>

  5124.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5125.     public static partial class Types {

  5126.       public sealed partial class FunctionGraphs : pb::IMessage<FunctionGraphs> {

  5127.         private static readonly pb::MessageParser<FunctionGraphs> _parser = new pb::MessageParser<FunctionGraphs>(() => new FunctionGraphs());

  5128.         private pb::UnknownFieldSet _unknownFields;

  5129.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5130.         public static pb::MessageParser<FunctionGraphs> Parser { get { return _parser; } }

  5131. 

  5132.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5133.         public static pbr::MessageDescriptor Descriptor {

  5134.           get { return global::Tensorflow.RunMetadata.Descriptor.NestedTypes[0]; }

  5135.         }

  5136. 

  5137.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5138.         pbr::MessageDescriptor pb::IMessage.Descriptor {

  5139.           get { return Descriptor; }

  5140.         }

  5141. 

  5142.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5143.         public FunctionGraphs() {

  5144.           OnConstruction();

  5145.         }

  5146. 

  5147.         partial void OnConstruction();

  5148. 

  5149.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5150.         public FunctionGraphs(FunctionGraphs other) : this() {

  5151.           partitionGraphs_ = other.partitionGraphs_.Clone();

  5152.           preOptimizationGraph_ = other.preOptimizationGraph_ != null ? other.preOptimizationGraph_.Clone() : null;

  5153.           postOptimizationGraph_ = other.postOptimizationGraph_ != null ? other.postOptimizationGraph_.Clone() : null;

  5154.           _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  5155.         }

  5156. 

  5157.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5158.         public FunctionGraphs Clone() {

  5159.           return new FunctionGraphs(this);

  5160.         }

  5161. 

  5162.         /// <summary>Field number for the "partition_graphs" field.</summary>

  5163.         public const int PartitionGraphsFieldNumber = 1;

  5164.         private static readonly pb::FieldCodec<global::Tensorflow.GraphDef> _repeated_partitionGraphs_codec

  5165.             = pb::FieldCodec.ForMessage(10, global::Tensorflow.GraphDef.Parser);

  5166.         private readonly pbc::RepeatedField<global::Tensorflow.GraphDef> partitionGraphs_ = new pbc::RepeatedField<global::Tensorflow.GraphDef>();

  5167.         /// <summary>

  5168.         /// TODO(nareshmodi): Include some sort of function/cache-key identifier?

  5169.         /// </summary>

  5170.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5171.         public pbc::RepeatedField<global::Tensorflow.GraphDef> PartitionGraphs {

  5172.           get { return partitionGraphs_; }

  5173.         }

  5174. 

  5175.         /// <summary>Field number for the "pre_optimization_graph" field.</summary>

  5176.         public const int PreOptimizationGraphFieldNumber = 2;

  5177.         private global::Tensorflow.GraphDef preOptimizationGraph_;

  5178.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5179.         public global::Tensorflow.GraphDef PreOptimizationGraph {

  5180.           get { return preOptimizationGraph_; }

  5181.           set {

  5182.             preOptimizationGraph_ = value;

  5183.           }

  5184.         }

  5185. 

  5186.         /// <summary>Field number for the "post_optimization_graph" field.</summary>

  5187.         public const int PostOptimizationGraphFieldNumber = 3;

  5188.         private global::Tensorflow.GraphDef postOptimizationGraph_;

  5189.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5190.         public global::Tensorflow.GraphDef PostOptimizationGraph {

  5191.           get { return postOptimizationGraph_; }

  5192.           set {

  5193.             postOptimizationGraph_ = value;

  5194.           }

  5195.         }

  5196. 

  5197.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5198.         public override bool Equals(object other) {

  5199.           return Equals(other as FunctionGraphs);

  5200.         }

  5201. 

  5202.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5203.         public bool Equals(FunctionGraphs other) {

  5204.           if (ReferenceEquals(other, null)) {

  5205.             return false;

  5206.           }

  5207.           if (ReferenceEquals(other, this)) {

  5208.             return true;

  5209.           }

  5210.           if(!partitionGraphs_.Equals(other.partitionGraphs_)) return false;

  5211.           if (!object.Equals(PreOptimizationGraph, other.PreOptimizationGraph)) return false;

  5212.           if (!object.Equals(PostOptimizationGraph, other.PostOptimizationGraph)) return false;

  5213.           return Equals(_unknownFields, other._unknownFields);

  5214.         }

  5215. 

  5216.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5217.         public override int GetHashCode() {

  5218.           int hash = 1;

  5219.           hash ^= partitionGraphs_.GetHashCode();

  5220.           if (preOptimizationGraph_ != null) hash ^= PreOptimizationGraph.GetHashCode();

  5221.           if (postOptimizationGraph_ != null) hash ^= PostOptimizationGraph.GetHashCode();

  5222.           if (_unknownFields != null) {

  5223.             hash ^= _unknownFields.GetHashCode();

  5224.           }

  5225.           return hash;

  5226.         }

  5227. 

  5228.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5229.         public override string ToString() {

  5230.           return pb::JsonFormatter.ToDiagnosticString(this);

  5231.         }

  5232. 

  5233.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5234.         public void WriteTo(pb::CodedOutputStream output) {

  5235.           partitionGraphs_.WriteTo(output, _repeated_partitionGraphs_codec);

  5236.           if (preOptimizationGraph_ != null) {

  5237.             output.WriteRawTag(18);

  5238.             output.WriteMessage(PreOptimizationGraph);

  5239.           }

  5240.           if (postOptimizationGraph_ != null) {

  5241.             output.WriteRawTag(26);

  5242.             output.WriteMessage(PostOptimizationGraph);

  5243.           }

  5244.           if (_unknownFields != null) {

  5245.             _unknownFields.WriteTo(output);

  5246.           }

  5247.         }

  5248. 

  5249.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5250.         public int CalculateSize() {

  5251.           int size = 0;

  5252.           size += partitionGraphs_.CalculateSize(_repeated_partitionGraphs_codec);

  5253.           if (preOptimizationGraph_ != null) {

  5254.             size += 1 + pb::CodedOutputStream.ComputeMessageSize(PreOptimizationGraph);

  5255.           }

  5256.           if (postOptimizationGraph_ != null) {

  5257.             size += 1 + pb::CodedOutputStream.ComputeMessageSize(PostOptimizationGraph);

  5258.           }

  5259.           if (_unknownFields != null) {

  5260.             size += _unknownFields.CalculateSize();

  5261.           }

  5262.           return size;

  5263.         }

  5264. 

  5265.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5266.         public void MergeFrom(FunctionGraphs other) {

  5267.           if (other == null) {

  5268.             return;

  5269.           }

  5270.           partitionGraphs_.Add(other.partitionGraphs_);

  5271.           if (other.preOptimizationGraph_ != null) {

  5272.             if (preOptimizationGraph_ == null) {

  5273.               PreOptimizationGraph = new global::Tensorflow.GraphDef();

  5274.             }

  5275.             PreOptimizationGraph.MergeFrom(other.PreOptimizationGraph);

  5276.           }

  5277.           if (other.postOptimizationGraph_ != null) {

  5278.             if (postOptimizationGraph_ == null) {

  5279.               PostOptimizationGraph = new global::Tensorflow.GraphDef();

  5280.             }

  5281.             PostOptimizationGraph.MergeFrom(other.PostOptimizationGraph);

  5282.           }

  5283.           _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  5284.         }

  5285. 

  5286.         [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5287.         public void MergeFrom(pb::CodedInputStream input) {

  5288.           uint tag;

  5289.           while ((tag = input.ReadTag()) != 0) {

  5290.             switch(tag) {

  5291.               default:

  5292.                 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  5293.                 break;

  5294.               case 10: {

  5295.                 partitionGraphs_.AddEntriesFrom(input, _repeated_partitionGraphs_codec);

  5296.                 break;

  5297.               }

  5298.               case 18: {

  5299.                 if (preOptimizationGraph_ == null) {

  5300.                   PreOptimizationGraph = new global::Tensorflow.GraphDef();

  5301.                 }

  5302.                 input.ReadMessage(PreOptimizationGraph);

  5303.                 break;

  5304.               }

  5305.               case 26: {

  5306.                 if (postOptimizationGraph_ == null) {

  5307.                   PostOptimizationGraph = new global::Tensorflow.GraphDef();

  5308.                 }

  5309.                 input.ReadMessage(PostOptimizationGraph);

  5310.                 break;

  5311.               }

  5312.             }

  5313.           }

  5314.         }

  5315. 

  5316.       }

  5317. 

  5318.     }

  5319.     #endregion

  5320. 

  5321.   }

  5322. 

  5323.   /// <summary>

  5324.   /// Defines a connection between two tensors in a `GraphDef`.

  5325.   /// </summary>

  5326.   public sealed partial class TensorConnection : pb::IMessage<TensorConnection> {

  5327.     private static readonly pb::MessageParser<TensorConnection> _parser = new pb::MessageParser<TensorConnection>(() => new TensorConnection());

  5328.     private pb::UnknownFieldSet _unknownFields;

  5329.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5330.     public static pb::MessageParser<TensorConnection> Parser { get { return _parser; } }

  5331. 

  5332.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5333.     public static pbr::MessageDescriptor Descriptor {

  5334.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[9]; }

  5335.     }

  5336. 

  5337.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5338.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  5339.       get { return Descriptor; }

  5340.     }

  5341. 

  5342.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5343.     public TensorConnection() {

  5344.       OnConstruction();

  5345.     }

  5346. 

  5347.     partial void OnConstruction();

  5348. 

  5349.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5350.     public TensorConnection(TensorConnection other) : this() {

  5351.       fromTensor_ = other.fromTensor_;

  5352.       toTensor_ = other.toTensor_;

  5353.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  5354.     }

  5355. 

  5356.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5357.     public TensorConnection Clone() {

  5358.       return new TensorConnection(this);

  5359.     }

  5360. 

  5361.     /// <summary>Field number for the "from_tensor" field.</summary>

  5362.     public const int FromTensorFieldNumber = 1;

  5363.     private string fromTensor_ = "";

  5364.     /// <summary>

  5365.     /// A tensor name. The value of this tensor will be substituted for

  5366.     /// the tensor named in `to_tensor`.

  5367.     /// </summary>

  5368.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5369.     public string FromTensor {

  5370.       get { return fromTensor_; }

  5371.       set {

  5372.         fromTensor_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  5373.       }

  5374.     }

  5375. 

  5376.     /// <summary>Field number for the "to_tensor" field.</summary>

  5377.     public const int ToTensorFieldNumber = 2;

  5378.     private string toTensor_ = "";

  5379.     /// <summary>

  5380.     /// A tensor name. The value of this tensor will be bound to the

  5381.     /// value of the tensor named in `from_tensor`.

  5382.     /// </summary>

  5383.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5384.     public string ToTensor {

  5385.       get { return toTensor_; }

  5386.       set {

  5387.         toTensor_ = pb::ProtoPreconditions.CheckNotNull(value, "value");

  5388.       }

  5389.     }

  5390. 

  5391.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5392.     public override bool Equals(object other) {

  5393.       return Equals(other as TensorConnection);

  5394.     }

  5395. 

  5396.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5397.     public bool Equals(TensorConnection other) {

  5398.       if (ReferenceEquals(other, null)) {

  5399.         return false;

  5400.       }

  5401.       if (ReferenceEquals(other, this)) {

  5402.         return true;

  5403.       }

  5404.       if (FromTensor != other.FromTensor) return false;

  5405.       if (ToTensor != other.ToTensor) return false;

  5406.       return Equals(_unknownFields, other._unknownFields);

  5407.     }

  5408. 

  5409.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5410.     public override int GetHashCode() {

  5411.       int hash = 1;

  5412.       if (FromTensor.Length != 0) hash ^= FromTensor.GetHashCode();

  5413.       if (ToTensor.Length != 0) hash ^= ToTensor.GetHashCode();

  5414.       if (_unknownFields != null) {

  5415.         hash ^= _unknownFields.GetHashCode();

  5416.       }

  5417.       return hash;

  5418.     }

  5419. 

  5420.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5421.     public override string ToString() {

  5422.       return pb::JsonFormatter.ToDiagnosticString(this);

  5423.     }

  5424. 

  5425.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5426.     public void WriteTo(pb::CodedOutputStream output) {

  5427.       if (FromTensor.Length != 0) {

  5428.         output.WriteRawTag(10);

  5429.         output.WriteString(FromTensor);

  5430.       }

  5431.       if (ToTensor.Length != 0) {

  5432.         output.WriteRawTag(18);

  5433.         output.WriteString(ToTensor);

  5434.       }

  5435.       if (_unknownFields != null) {

  5436.         _unknownFields.WriteTo(output);

  5437.       }

  5438.     }

  5439. 

  5440.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5441.     public int CalculateSize() {

  5442.       int size = 0;

  5443.       if (FromTensor.Length != 0) {

  5444.         size += 1 + pb::CodedOutputStream.ComputeStringSize(FromTensor);

  5445.       }

  5446.       if (ToTensor.Length != 0) {

  5447.         size += 1 + pb::CodedOutputStream.ComputeStringSize(ToTensor);

  5448.       }

  5449.       if (_unknownFields != null) {

  5450.         size += _unknownFields.CalculateSize();

  5451.       }

  5452.       return size;

  5453.     }

  5454. 

  5455.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5456.     public void MergeFrom(TensorConnection other) {

  5457.       if (other == null) {

  5458.         return;

  5459.       }

  5460.       if (other.FromTensor.Length != 0) {

  5461.         FromTensor = other.FromTensor;

  5462.       }

  5463.       if (other.ToTensor.Length != 0) {

  5464.         ToTensor = other.ToTensor;

  5465.       }

  5466.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  5467.     }

  5468. 

  5469.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5470.     public void MergeFrom(pb::CodedInputStream input) {

  5471.       uint tag;

  5472.       while ((tag = input.ReadTag()) != 0) {

  5473.         switch(tag) {

  5474.           default:

  5475.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  5476.             break;

  5477.           case 10: {

  5478.             FromTensor = input.ReadString();

  5479.             break;

  5480.           }

  5481.           case 18: {

  5482.             ToTensor = input.ReadString();

  5483.             break;

  5484.           }

  5485.         }

  5486.       }

  5487.     }

  5488. 

  5489.   }

  5490. 

  5491.   /// <summary>

  5492.   /// Defines a subgraph in another `GraphDef` as a set of feed points and nodes

  5493.   /// to be fetched or executed.

  5494.   ///

  5495.   /// Compare with the arguments to `Session::Run()`.

  5496.   /// </summary>

  5497.   public sealed partial class CallableOptions : pb::IMessage<CallableOptions> {

  5498.     private static readonly pb::MessageParser<CallableOptions> _parser = new pb::MessageParser<CallableOptions>(() => new CallableOptions());

  5499.     private pb::UnknownFieldSet _unknownFields;

  5500.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5501.     public static pb::MessageParser<CallableOptions> Parser { get { return _parser; } }

  5502. 

  5503.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5504.     public static pbr::MessageDescriptor Descriptor {

  5505.       get { return global::Tensorflow.ConfigReflection.Descriptor.MessageTypes[10]; }

  5506.     }

  5507. 

  5508.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5509.     pbr::MessageDescriptor pb::IMessage.Descriptor {

  5510.       get { return Descriptor; }

  5511.     }

  5512. 

  5513.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5514.     public CallableOptions() {

  5515.       OnConstruction();

  5516.     }

  5517. 

  5518.     partial void OnConstruction();

  5519. 

  5520.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5521.     public CallableOptions(CallableOptions other) : this() {

  5522.       feed_ = other.feed_.Clone();

  5523.       fetch_ = other.fetch_.Clone();

  5524.       target_ = other.target_.Clone();

  5525.       runOptions_ = other.runOptions_ != null ? other.runOptions_.Clone() : null;

  5526.       tensorConnection_ = other.tensorConnection_.Clone();

  5527.       feedDevices_ = other.feedDevices_.Clone();

  5528.       fetchDevices_ = other.fetchDevices_.Clone();

  5529.       fetchSkipSync_ = other.fetchSkipSync_;

  5530.       _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);

  5531.     }

  5532. 

  5533.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5534.     public CallableOptions Clone() {

  5535.       return new CallableOptions(this);

  5536.     }

  5537. 

  5538.     /// <summary>Field number for the "feed" field.</summary>

  5539.     public const int FeedFieldNumber = 1;

  5540.     private static readonly pb::FieldCodec<string> _repeated_feed_codec

  5541.         = pb::FieldCodec.ForString(10);

  5542.     private readonly pbc::RepeatedField<string> feed_ = new pbc::RepeatedField<string>();

  5543.     /// <summary>

  5544.     /// Tensors to be fed in the callable. Each feed is the name of a tensor.

  5545.     /// </summary>

  5546.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5547.     public pbc::RepeatedField<string> Feed {

  5548.       get { return feed_; }

  5549.     }

  5550. 

  5551.     /// <summary>Field number for the "fetch" field.</summary>

  5552.     public const int FetchFieldNumber = 2;

  5553.     private static readonly pb::FieldCodec<string> _repeated_fetch_codec

  5554.         = pb::FieldCodec.ForString(18);

  5555.     private readonly pbc::RepeatedField<string> fetch_ = new pbc::RepeatedField<string>();

  5556.     /// <summary>

  5557.     /// Fetches. A list of tensor names. The caller of the callable expects a

  5558.     /// tensor to be returned for each fetch[i] (see RunStepResponse.tensor). The

  5559.     /// order of specified fetches does not change the execution order.

  5560.     /// </summary>

  5561.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5562.     public pbc::RepeatedField<string> Fetch {

  5563.       get { return fetch_; }

  5564.     }

  5565. 

  5566.     /// <summary>Field number for the "target" field.</summary>

  5567.     public const int TargetFieldNumber = 3;

  5568.     private static readonly pb::FieldCodec<string> _repeated_target_codec

  5569.         = pb::FieldCodec.ForString(26);

  5570.     private readonly pbc::RepeatedField<string> target_ = new pbc::RepeatedField<string>();

  5571.     /// <summary>

  5572.     /// Target Nodes. A list of node names. The named nodes will be run by the

  5573.     /// callable but their outputs will not be returned.

  5574.     /// </summary>

  5575.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5576.     public pbc::RepeatedField<string> Target {

  5577.       get { return target_; }

  5578.     }

  5579. 

  5580.     /// <summary>Field number for the "run_options" field.</summary>

  5581.     public const int RunOptionsFieldNumber = 4;

  5582.     private global::Tensorflow.RunOptions runOptions_;

  5583.     /// <summary>

  5584.     /// Options that will be applied to each run.

  5585.     /// </summary>

  5586.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5587.     public global::Tensorflow.RunOptions RunOptions {

  5588.       get { return runOptions_; }

  5589.       set {

  5590.         runOptions_ = value;

  5591.       }

  5592.     }

  5593. 

  5594.     /// <summary>Field number for the "tensor_connection" field.</summary>

  5595.     public const int TensorConnectionFieldNumber = 5;

  5596.     private static readonly pb::FieldCodec<global::Tensorflow.TensorConnection> _repeated_tensorConnection_codec

  5597.         = pb::FieldCodec.ForMessage(42, global::Tensorflow.TensorConnection.Parser);

  5598.     private readonly pbc::RepeatedField<global::Tensorflow.TensorConnection> tensorConnection_ = new pbc::RepeatedField<global::Tensorflow.TensorConnection>();

  5599.     /// <summary>

  5600.     /// Tensors to be connected in the callable. Each TensorConnection denotes

  5601.     /// a pair of tensors in the graph, between which an edge will be created

  5602.     /// in the callable.

  5603.     /// </summary>

  5604.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5605.     public pbc::RepeatedField<global::Tensorflow.TensorConnection> TensorConnection {

  5606.       get { return tensorConnection_; }

  5607.     }

  5608. 

  5609.     /// <summary>Field number for the "feed_devices" field.</summary>

  5610.     public const int FeedDevicesFieldNumber = 6;

  5611.     private static readonly pbc::MapField<string, string>.Codec _map_feedDevices_codec

  5612.         = new pbc::MapField<string, string>.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 50);

  5613.     private readonly pbc::MapField<string, string> feedDevices_ = new pbc::MapField<string, string>();

  5614.     /// <summary>

  5615.     /// The Tensor objects fed in the callable and fetched from the callable

  5616.     /// are expected to be backed by host (CPU) memory by default.

  5617.     ///

  5618.     /// The options below allow changing that - feeding tensors backed by

  5619.     /// device memory, or returning tensors that are backed by device memory.

  5620.     ///

  5621.     /// The maps below map the name of a feed/fetch tensor (which appears in

  5622.     /// 'feed' or 'fetch' fields above), to the fully qualified name of the device

  5623.     /// owning the memory backing the contents of the tensor.

  5624.     ///

  5625.     /// For example, creating a callable with the following options:

  5626.     ///

  5627.     /// CallableOptions {

  5628.     ///   feed: "a:0"

  5629.     ///   feed: "b:0"

  5630.     ///

  5631.     ///   fetch: "x:0"

  5632.     ///   fetch: "y:0"

  5633.     ///

  5634.     ///   feed_devices: {

  5635.     ///     "a:0": "/job:localhost/replica:0/task:0/device:GPU:0"

  5636.     ///   }

  5637.     ///

  5638.     ///   fetch_devices: {

  5639.     ///     "y:0": "/job:localhost/replica:0/task:0/device:GPU:0"

  5640.     ///  }

  5641.     /// }

  5642.     ///

  5643.     /// means that the Callable expects:

  5644.     /// - The first argument ("a:0") is a Tensor backed by GPU memory.

  5645.     /// - The second argument ("b:0") is a Tensor backed by host memory.

  5646.     /// and of its return values:

  5647.     /// - The first output ("x:0") will be backed by host memory.

  5648.     /// - The second output ("y:0") will be backed by GPU memory.

  5649.     ///

  5650.     /// FEEDS:

  5651.     /// It is the responsibility of the caller to ensure that the memory of the fed

  5652.     /// tensors will be correctly initialized and synchronized before it is

  5653.     /// accessed by operations executed during the call to Session::RunCallable().

  5654.     ///

  5655.     /// This is typically ensured by using the TensorFlow memory allocators

  5656.     /// (Device::GetAllocator()) to create the Tensor to be fed.

  5657.     ///

  5658.     /// Alternatively, for CUDA-enabled GPU devices, this typically means that the

  5659.     /// operation that produced the contents of the tensor has completed, i.e., the

  5660.     /// CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or

  5661.     /// cuStreamSynchronize()).

  5662.     /// </summary>

  5663.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5664.     public pbc::MapField<string, string> FeedDevices {

  5665.       get { return feedDevices_; }

  5666.     }

  5667. 

  5668.     /// <summary>Field number for the "fetch_devices" field.</summary>

  5669.     public const int FetchDevicesFieldNumber = 7;

  5670.     private static readonly pbc::MapField<string, string>.Codec _map_fetchDevices_codec

  5671.         = new pbc::MapField<string, string>.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForString(18, ""), 58);

  5672.     private readonly pbc::MapField<string, string> fetchDevices_ = new pbc::MapField<string, string>();

  5673.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5674.     public pbc::MapField<string, string> FetchDevices {

  5675.       get { return fetchDevices_; }

  5676.     }

  5677. 

  5678.     /// <summary>Field number for the "fetch_skip_sync" field.</summary>

  5679.     public const int FetchSkipSyncFieldNumber = 8;

  5680.     private bool fetchSkipSync_;

  5681.     /// <summary>

  5682.     /// By default, RunCallable() will synchronize the GPU stream before returning

  5683.     /// fetched tensors on a GPU device, to ensure that the values in those tensors

  5684.     /// have been produced. This simplifies interacting with the tensors, but

  5685.     /// potentially incurs a performance hit.

  5686.     ///

  5687.     /// If this options is set to true, the caller is responsible for ensuring

  5688.     /// that the values in the fetched tensors have been produced before they are

  5689.     /// used. The caller can do this by invoking `Device::Sync()` on the underlying

  5690.     /// device(s), or by feeding the tensors back to the same Session using

  5691.     /// `feed_devices` with the same corresponding device name.

  5692.     /// </summary>

  5693.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5694.     public bool FetchSkipSync {

  5695.       get { return fetchSkipSync_; }

  5696.       set {

  5697.         fetchSkipSync_ = value;

  5698.       }

  5699.     }

  5700. 

  5701.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5702.     public override bool Equals(object other) {

  5703.       return Equals(other as CallableOptions);

  5704.     }

  5705. 

  5706.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5707.     public bool Equals(CallableOptions other) {

  5708.       if (ReferenceEquals(other, null)) {

  5709.         return false;

  5710.       }

  5711.       if (ReferenceEquals(other, this)) {

  5712.         return true;

  5713.       }

  5714.       if(!feed_.Equals(other.feed_)) return false;

  5715.       if(!fetch_.Equals(other.fetch_)) return false;

  5716.       if(!target_.Equals(other.target_)) return false;

  5717.       if (!object.Equals(RunOptions, other.RunOptions)) return false;

  5718.       if(!tensorConnection_.Equals(other.tensorConnection_)) return false;

  5719.       if (!FeedDevices.Equals(other.FeedDevices)) return false;

  5720.       if (!FetchDevices.Equals(other.FetchDevices)) return false;

  5721.       if (FetchSkipSync != other.FetchSkipSync) return false;

  5722.       return Equals(_unknownFields, other._unknownFields);

  5723.     }

  5724. 

  5725.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5726.     public override int GetHashCode() {

  5727.       int hash = 1;

  5728.       hash ^= feed_.GetHashCode();

  5729.       hash ^= fetch_.GetHashCode();

  5730.       hash ^= target_.GetHashCode();

  5731.       if (runOptions_ != null) hash ^= RunOptions.GetHashCode();

  5732.       hash ^= tensorConnection_.GetHashCode();

  5733.       hash ^= FeedDevices.GetHashCode();

  5734.       hash ^= FetchDevices.GetHashCode();

  5735.       if (FetchSkipSync != false) hash ^= FetchSkipSync.GetHashCode();

  5736.       if (_unknownFields != null) {

  5737.         hash ^= _unknownFields.GetHashCode();

  5738.       }

  5739.       return hash;

  5740.     }

  5741. 

  5742.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5743.     public override string ToString() {

  5744.       return pb::JsonFormatter.ToDiagnosticString(this);

  5745.     }

  5746. 

  5747.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5748.     public void WriteTo(pb::CodedOutputStream output) {

  5749.       feed_.WriteTo(output, _repeated_feed_codec);

  5750.       fetch_.WriteTo(output, _repeated_fetch_codec);

  5751.       target_.WriteTo(output, _repeated_target_codec);

  5752.       if (runOptions_ != null) {

  5753.         output.WriteRawTag(34);

  5754.         output.WriteMessage(RunOptions);

  5755.       }

  5756.       tensorConnection_.WriteTo(output, _repeated_tensorConnection_codec);

  5757.       feedDevices_.WriteTo(output, _map_feedDevices_codec);

  5758.       fetchDevices_.WriteTo(output, _map_fetchDevices_codec);

  5759.       if (FetchSkipSync != false) {

  5760.         output.WriteRawTag(64);

  5761.         output.WriteBool(FetchSkipSync);

  5762.       }

  5763.       if (_unknownFields != null) {

  5764.         _unknownFields.WriteTo(output);

  5765.       }

  5766.     }

  5767. 

  5768.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5769.     public int CalculateSize() {

  5770.       int size = 0;

  5771.       size += feed_.CalculateSize(_repeated_feed_codec);

  5772.       size += fetch_.CalculateSize(_repeated_fetch_codec);

  5773.       size += target_.CalculateSize(_repeated_target_codec);

  5774.       if (runOptions_ != null) {

  5775.         size += 1 + pb::CodedOutputStream.ComputeMessageSize(RunOptions);

  5776.       }

  5777.       size += tensorConnection_.CalculateSize(_repeated_tensorConnection_codec);

  5778.       size += feedDevices_.CalculateSize(_map_feedDevices_codec);

  5779.       size += fetchDevices_.CalculateSize(_map_fetchDevices_codec);

  5780.       if (FetchSkipSync != false) {

  5781.         size += 1 + 1;

  5782.       }

  5783.       if (_unknownFields != null) {

  5784.         size += _unknownFields.CalculateSize();

  5785.       }

  5786.       return size;

  5787.     }

  5788. 

  5789.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5790.     public void MergeFrom(CallableOptions other) {

  5791.       if (other == null) {

  5792.         return;

  5793.       }

  5794.       feed_.Add(other.feed_);

  5795.       fetch_.Add(other.fetch_);

  5796.       target_.Add(other.target_);

  5797.       if (other.runOptions_ != null) {

  5798.         if (runOptions_ == null) {

  5799.           RunOptions = new global::Tensorflow.RunOptions();

  5800.         }

  5801.         RunOptions.MergeFrom(other.RunOptions);

  5802.       }

  5803.       tensorConnection_.Add(other.tensorConnection_);

  5804.       feedDevices_.Add(other.feedDevices_);

  5805.       fetchDevices_.Add(other.fetchDevices_);

  5806.       if (other.FetchSkipSync != false) {

  5807.         FetchSkipSync = other.FetchSkipSync;

  5808.       }

  5809.       _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);

  5810.     }

  5811. 

  5812.     [global::System.Diagnostics.DebuggerNonUserCodeAttribute]

  5813.     public void MergeFrom(pb::CodedInputStream input) {

  5814.       uint tag;

  5815.       while ((tag = input.ReadTag()) != 0) {

  5816.         switch(tag) {

  5817.           default:

  5818.             _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);

  5819.             break;

  5820.           case 10: {

  5821.             feed_.AddEntriesFrom(input, _repeated_feed_codec);

  5822.             break;

  5823.           }

  5824.           case 18: {

  5825.             fetch_.AddEntriesFrom(input, _repeated_fetch_codec);

  5826.             break;

  5827.           }

  5828.           case 26: {

  5829.             target_.AddEntriesFrom(input, _repeated_target_codec);

  5830.             break;

  5831.           }

  5832.           case 34: {

  5833.             if (runOptions_ == null) {

  5834.               RunOptions = new global::Tensorflow.RunOptions();

  5835.             }

  5836.             input.ReadMessage(RunOptions);

  5837.             break;

  5838.           }

  5839.           case 42: {

  5840.             tensorConnection_.AddEntriesFrom(input, _repeated_tensorConnection_codec);

  5841.             break;

  5842.           }

  5843.           case 50: {

  5844.             feedDevices_.AddEntriesFrom(input, _map_feedDevices_codec);

  5845.             break;

  5846.           }

  5847.           case 58: {

  5848.             fetchDevices_.AddEntriesFrom(input, _map_fetchDevices_codec);

  5849.             break;

  5850.           }

  5851.           case 64: {

  5852.             FetchSkipSync = input.ReadBool();

  5853.             break;

  5854.           }

  5855.         }

  5856.       }

  5857.     }

  5858. 

  5859.   }

  5860. 

  5861.   #endregion

  5862. 

  5863. }

  5864. 

  5865. #endregion Designer generated code