// <auto-generated>

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

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

// </auto-generated>

#pragma warning disable 1591, 0612, 3021, 8981

#region Designer generated code

using pb = global::Google.Protobuf;

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

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

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

namespace Tensorflow {

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

public static partial class ConfigReflection {

#region Descriptor

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

public static pbr::FileDescriptor Descriptor {

get { return descriptor; }

}

private static pbr::FileDescriptor descriptor;

static ConfigReflection() {

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

string.Concat(

"CiV0ZW5zb3JmbG93L2NvcmUvcHJvdG9idWYvY29uZmlnLnByb3RvEgp0ZW5z",

"b3JmbG93Gip0ZW5zb3JmbG93L2NvcmUvZnJhbWV3b3JrL2Nvc3RfZ3JhcGgu",

"cHJvdG8aJXRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvZ3JhcGgucHJvdG8a",

"KnRlbnNvcmZsb3cvY29yZS9mcmFtZXdvcmsvc3RlcF9zdGF0cy5wcm90bxom",

"dGVuc29yZmxvdy9jb3JlL3Byb3RvYnVmL2NsdXN0ZXIucHJvdG8aMnRlbnNv",

"cmZsb3cvY29yZS9wcm90b2J1Zi9jb29yZGluYXRpb25fY29uZmlnLnByb3Rv",

"GiR0ZW5zb3JmbG93L2NvcmUvcHJvdG9idWYvZGVidWcucHJvdG8aLnRlbnNv",

"cmZsb3cvY29yZS9wcm90b2J1Zi9yZXdyaXRlcl9jb25maWcucHJvdG8i1wYK",

"CkdQVU9wdGlvbnMSJwofcGVyX3Byb2Nlc3NfZ3B1X21lbW9yeV9mcmFjdGlv",

"bhgBIAEoARIUCgxhbGxvd19ncm93dGgYBCABKAgSFgoOYWxsb2NhdG9yX3R5",

"cGUYAiABKAkSHwoXZGVmZXJyZWRfZGVsZXRpb25fYnl0ZXMYAyABKAMSGwoT",

"dmlzaWJsZV9kZXZpY2VfbGlzdBgFIAEoCRIiChpwb2xsaW5nX2FjdGl2ZV9k",

"ZWxheV91c2VjcxgGIAEoBRIkChxwb2xsaW5nX2luYWN0aXZlX2RlbGF5X21z",

"ZWNzGAcgASgFEhwKFGZvcmNlX2dwdV9jb21wYXRpYmxlGAggASgIEjkKDGV4",

"cGVyaW1lbnRhbBgJIAEoCzIjLnRlbnNvcmZsb3cuR1BVT3B0aW9ucy5FeHBl",

"cmltZW50YWwakAQKDEV4cGVyaW1lbnRhbBJLCg92aXJ0dWFsX2RldmljZXMY",

"ASADKAsyMi50ZW5zb3JmbG93LkdQVU9wdGlvbnMuRXhwZXJpbWVudGFsLlZp",

"cnR1YWxEZXZpY2VzEhoKEnVzZV91bmlmaWVkX21lbW9yeRgCIAEoCBIjChtu",

"dW1fZGV2X3RvX2Rldl9jb3B5X3N0cmVhbXMYAyABKAUSHQoVY29sbGVjdGl2",

"ZV9yaW5nX29yZGVyGAQgASgJEh0KFXRpbWVzdGFtcGVkX2FsbG9jYXRvchgF",

"IAEoCBIjChtrZXJuZWxfdHJhY2tlcl9tYXhfaW50ZXJ2YWwYByABKAUSIAoY",

"a2VybmVsX3RyYWNrZXJfbWF4X2J5dGVzGAggASgFEiIKGmtlcm5lbF90cmFj",

"a2VyX21heF9wZW5kaW5nGAkgASgFEicKH2ludGVybmFsX2ZyYWdtZW50YXRp",

"b25fZnJhY3Rpb24YCiABKAESHQoVdXNlX2N1ZGFfbWFsbG9jX2FzeW5jGAsg",

"ASgIEiwKJGRpc2FsbG93X3JldHJ5X29uX2FsbG9jYXRpb25fZmFpbHVyZRgM",

"IAEoCBpTCg5WaXJ0dWFsRGV2aWNlcxIXCg9tZW1vcnlfbGltaXRfbWIYASAD",

"KAISEAoIcHJpb3JpdHkYAiADKAUSFgoOZGV2aWNlX29yZGluYWwYAyADKAUi",

"nQMKEE9wdGltaXplck9wdGlvbnMSKwojZG9fY29tbW9uX3N1YmV4cHJlc3Np",

"b25fZWxpbWluYXRpb24YASABKAgSGwoTZG9fY29uc3RhbnRfZm9sZGluZxgC",

"IAEoCBIkChxtYXhfZm9sZGVkX2NvbnN0YW50X2luX2J5dGVzGAYgASgDEhwK",

"FGRvX2Z1bmN0aW9uX2lubGluaW5nGAQgASgIEjUKCW9wdF9sZXZlbBgDIAEo",

"DjIiLnRlbnNvcmZsb3cuT3B0aW1pemVyT3B0aW9ucy5MZXZlbBJFChBnbG9i",

"YWxfaml0X2xldmVsGAUgASgOMisudGVuc29yZmxvdy5PcHRpbWl6ZXJPcHRp",

"b25zLkdsb2JhbEppdExldmVsEhYKDmNwdV9nbG9iYWxfaml0GAcgASgIIiAK",

"BUxldmVsEgYKAkwxEAASDwoCTDAQ////////////ASJDCg5HbG9iYWxKaXRM",

"ZXZlbBILCgdERUZBVUxUEAASEAoDT0ZGEP///////////wESCAoET05fMRAB",

"EggKBE9OXzIQAiLuAgoMR3JhcGhPcHRpb25zEh4KFmVuYWJsZV9yZWN2X3Nj",

"aGVkdWxpbmcYAiABKAgSNwoRb3B0aW1pemVyX29wdGlvbnMYAyABKAsyHC50",

"ZW5zb3JmbG93Lk9wdGltaXplck9wdGlvbnMSGAoQYnVpbGRfY29zdF9tb2Rl",

"bBgEIAEoAxIeChZidWlsZF9jb3N0X21vZGVsX2FmdGVyGAkgASgDEhQKDGlu",

"ZmVyX3NoYXBlcxgFIAEoCBIaChJwbGFjZV9wcnVuZWRfZ3JhcGgYBiABKAgS",

"IAoYZW5hYmxlX2JmbG9hdDE2X3NlbmRyZWN2GAcgASgIEhUKDXRpbWVsaW5l",

"X3N0ZXAYCCABKAUSMwoPcmV3cml0ZV9vcHRpb25zGAogASgLMhoudGVuc29y",

"Zmxvdy5SZXdyaXRlckNvbmZpZ0oECAEQAlIlc2tpcF9jb21tb25fc3ViZXhw",

"cmVzc2lvbl9lbGltaW5hdGlvbiJBChVUaHJlYWRQb29sT3B0aW9uUHJvdG8S",

"EwoLbnVtX3RocmVhZHMYASABKAUSEwoLZ2xvYmFsX25hbWUYAiABKAki1QEK",

"ClJQQ09wdGlvbnMSJAocdXNlX3JwY19mb3JfaW5wcm9jZXNzX21hc3RlchgB",

"IAEoCBIdChVjb21wcmVzc2lvbl9hbGdvcml0aG0YAiABKAkSGQoRY29tcHJl",

"c3Npb25fbGV2ZWwYAyABKAUSGgoSY2FjaGVfcnBjX3Jlc3BvbnNlGAQgASgI",

"EioKImRpc2FibGVfc2Vzc2lvbl9jb25uZWN0aW9uX3NoYXJpbmcYBSABKAgS",

"HwoXbnVtX2NoYW5uZWxzX3Blcl90YXJnZXQYBiABKAUiMAoPU2Vzc2lvbk1l",

"dGFkYXRhEgwKBG5hbWUYASABKAkSDwoHdmVyc2lvbhgCIAEoAyKuDgoLQ29u",

"ZmlnUHJvdG8SPgoMZGV2aWNlX2NvdW50GAEgAygLMigudGVuc29yZmxvdy5D",

"b25maWdQcm90by5EZXZpY2VDb3VudEVudHJ5EiQKHGludHJhX29wX3BhcmFs",

"bGVsaXNtX3RocmVhZHMYAiABKAUSJAocaW50ZXJfb3BfcGFyYWxsZWxpc21f",

"dGhyZWFkcxgFIAEoBRIfChd1c2VfcGVyX3Nlc3Npb25fdGhyZWFkcxgJIAEo",

"CBJHChxzZXNzaW9uX2ludGVyX29wX3RocmVhZF9wb29sGAwgAygLMiEudGVu",

"c29yZmxvdy5UaHJlYWRQb29sT3B0aW9uUHJvdG8SGAoQcGxhY2VtZW50X3Bl",

"cmlvZBgDIAEoBRIWCg5kZXZpY2VfZmlsdGVycxgEIAMoCRIrCgtncHVfb3B0",

"aW9ucxgGIAEoCzIWLnRlbnNvcmZsb3cuR1BVT3B0aW9ucxIcChRhbGxvd19z",

"b2Z0X3BsYWNlbWVudBgHIAEoCBIcChRsb2dfZGV2aWNlX3BsYWNlbWVudBgI",

"IAEoCBIvCg1ncmFwaF9vcHRpb25zGAogASgLMhgudGVuc29yZmxvdy5HcmFw",

"aE9wdGlvbnMSHwoXb3BlcmF0aW9uX3RpbWVvdXRfaW5fbXMYCyABKAMSKwoL",

"cnBjX29wdGlvbnMYDSABKAsyFi50ZW5zb3JmbG93LlJQQ09wdGlvbnMSKwoL",

"Y2x1c3Rlcl9kZWYYDiABKAsyFi50ZW5zb3JmbG93LkNsdXN0ZXJEZWYSHQoV",

"aXNvbGF0ZV9zZXNzaW9uX3N0YXRlGA8gASgIEigKIHNoYXJlX2NsdXN0ZXJf",

"ZGV2aWNlc19pbl9zZXNzaW9uGBEgASgIEjoKDGV4cGVyaW1lbnRhbBgQIAEo",

"CzIkLnRlbnNvcmZsb3cuQ29uZmlnUHJvdG8uRXhwZXJpbWVudGFsGjIKEERl",

"dmljZUNvdW50RW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgFOgI4",

"ARqoCAoMRXhwZXJpbWVudGFsEh8KF2NvbGxlY3RpdmVfZ3JvdXBfbGVhZGVy",

"GAEgASgJEhUKDWV4ZWN1dG9yX3R5cGUYAyABKAkSGgoScmVjdl9idWZfbWF4",

"X2NodW5rGAQgASgFEhkKEXVzZV9udW1hX2FmZmluaXR5GAUgASgIEjUKLWNv",

"bGxlY3RpdmVfZGV0ZXJtaW5pc3RpY19zZXF1ZW50aWFsX2V4ZWN1dGlvbhgG",

"IAEoCBIXCg9jb2xsZWN0aXZlX25jY2wYByABKAgSNgouc2hhcmVfc2Vzc2lv",

"bl9zdGF0ZV9pbl9jbHVzdGVyc3BlY19wcm9wYWdhdGlvbhgIIAEoCBIfChdk",

"aXNhYmxlX3RocmVhZF9zcGlubmluZxgJIAEoCBIoCiBzaGFyZV9jbHVzdGVy",

"X2RldmljZXNfaW5fc2Vzc2lvbhgKIAEoCBI1ChBzZXNzaW9uX21ldGFkYXRh",

"GAsgASgLMhsudGVuc29yZmxvdy5TZXNzaW9uTWV0YWRhdGESIQoZb3B0aW1p",

"emVfZm9yX3N0YXRpY19ncmFwaBgMIAEoCBIaChJlbmFibGVfbWxpcl9icmlk",

"Z2UYDSABKAgSUwoTbWxpcl9icmlkZ2Vfcm9sbG91dBgRIAEoDjI2LnRlbnNv",

"cmZsb3cuQ29uZmlnUHJvdG8uRXhwZXJpbWVudGFsLk1saXJCcmlkZ2VSb2xs",

"b3V0EiYKHmVuYWJsZV9tbGlyX2dyYXBoX29wdGltaXphdGlvbhgQIAEoCBIn",

"Ch9kaXNhYmxlX291dHB1dF9wYXJ0aXRpb25fZ3JhcGhzGA4gASgIEiMKG3hs",

"YV9mdXNpb25fYXV0b3R1bmVyX3RocmVzaBgPIAEoAxIQCgh1c2VfdGZydBgS",

"IAEoCBInCh9kaXNhYmxlX2Z1bmN0aW9uYWxfb3BzX2xvd2VyaW5nGBUgASgI",

"EicKH3hsYV9wcmVmZXJfc2luZ2xlX2dyYXBoX2NsdXN0ZXIYFiABKAgSQgoT",

"Y29vcmRpbmF0aW9uX2NvbmZpZxgXIAEoCzIlLnRlbnNvcmZsb3cuQ29vcmRp",

"bmF0aW9uU2VydmljZUNvbmZpZyLaAQoRTWxpckJyaWRnZVJvbGxvdXQSIwof",

"TUxJUl9CUklER0VfUk9MTE9VVF9VTlNQRUNJRklFRBAAEh8KG01MSVJfQlJJ",

"REdFX1JPTExPVVRfRU5BQkxFRBABEiAKHE1MSVJfQlJJREdFX1JPTExPVVRf",

"RElTQUJMRUQQAhIpCiVNTElSX0JSSURHRV9ST0xMT1VUX1NBRkVfTU9ERV9F",

"TkFCTEVEEAMSMgouTUxJUl9CUklER0VfUk9MTE9VVF9TQUZFX01PREVfRkFM",

"TEJBQ0tfRU5BQkxFRBAESgQIAhADSgQIExAUSgQIFBAVIuEECgpSdW5PcHRp",

"b25zEjYKC3RyYWNlX2xldmVsGAEgASgOMiEudGVuc29yZmxvdy5SdW5PcHRp",

"b25zLlRyYWNlTGV2ZWwSFQoNdGltZW91dF9pbl9tcxgCIAEoAxIcChRpbnRl",

"cl9vcF90aHJlYWRfcG9vbBgDIAEoBRIfChdvdXRwdXRfcGFydGl0aW9uX2dy",

"YXBocxgFIAEoCBIvCg1kZWJ1Z19vcHRpb25zGAYgASgLMhgudGVuc29yZmxv",

"dy5EZWJ1Z09wdGlvbnMSKgoicmVwb3J0X3RlbnNvcl9hbGxvY2F0aW9uc191",

"cG9uX29vbRgHIAEoCBI5CgxleHBlcmltZW50YWwYCCABKAsyIy50ZW5zb3Jm",

"bG93LlJ1bk9wdGlvbnMuRXhwZXJpbWVudGFsGtIBCgxFeHBlcmltZW50YWwS",

"HAoUY29sbGVjdGl2ZV9ncmFwaF9rZXkYASABKAMSHAoUdXNlX3J1bl9oYW5k",

"bGVyX3Bvb2wYAiABKAgSWwoYcnVuX2hhbmRsZXJfcG9vbF9vcHRpb25zGAMg",

"ASgLMjkudGVuc29yZmxvdy5SdW5PcHRpb25zLkV4cGVyaW1lbnRhbC5SdW5I",

"YW5kbGVyUG9vbE9wdGlvbnMaKQoVUnVuSGFuZGxlclBvb2xPcHRpb25zEhAK",

"CHByaW9yaXR5GAEgASgDIlIKClRyYWNlTGV2ZWwSDAoITk9fVFJBQ0UQABIS",

"Cg5TT0ZUV0FSRV9UUkFDRRABEhIKDkhBUkRXQVJFX1RSQUNFEAISDgoKRlVM",

"TF9UUkFDRRADSgQIBBAFIr4DCgtSdW5NZXRhZGF0YRIpCgpzdGVwX3N0YXRz",

"GAEgASgLMhUudGVuc29yZmxvdy5TdGVwU3RhdHMSLAoKY29zdF9ncmFwaBgC",

"IAEoCzIYLnRlbnNvcmZsb3cuQ29zdEdyYXBoRGVmEi4KEHBhcnRpdGlvbl9n",

"cmFwaHMYAyADKAsyFC50ZW5zb3JmbG93LkdyYXBoRGVmEj8KD2Z1bmN0aW9u",

"X2dyYXBocxgEIAMoCzImLnRlbnNvcmZsb3cuUnVuTWV0YWRhdGEuRnVuY3Rp",

"b25HcmFwaHMSNQoQc2Vzc2lvbl9tZXRhZGF0YRgFIAEoCzIbLnRlbnNvcmZs",

"b3cuU2Vzc2lvbk1ldGFkYXRhGq0BCg5GdW5jdGlvbkdyYXBocxIuChBwYXJ0",

"aXRpb25fZ3JhcGhzGAEgAygLMhQudGVuc29yZmxvdy5HcmFwaERlZhI0ChZw",

"cmVfb3B0aW1pemF0aW9uX2dyYXBoGAIgASgLMhQudGVuc29yZmxvdy5HcmFw",

"aERlZhI1Chdwb3N0X29wdGltaXphdGlvbl9ncmFwaBgDIAEoCzIULnRlbnNv",

"cmZsb3cuR3JhcGhEZWYiOgoQVGVuc29yQ29ubmVjdGlvbhITCgtmcm9tX3Rl",

"bnNvchgBIAEoCRIRCgl0b190ZW5zb3IYAiABKAkisAMKD0NhbGxhYmxlT3B0",

"aW9ucxIMCgRmZWVkGAEgAygJEg0KBWZldGNoGAIgAygJEg4KBnRhcmdldBgD",

"IAMoCRIrCgtydW5fb3B0aW9ucxgEIAEoCzIWLnRlbnNvcmZsb3cuUnVuT3B0",

"aW9ucxI3ChF0ZW5zb3JfY29ubmVjdGlvbhgFIAMoCzIcLnRlbnNvcmZsb3cu",

"VGVuc29yQ29ubmVjdGlvbhJCCgxmZWVkX2RldmljZXMYBiADKAsyLC50ZW5z",

"b3JmbG93LkNhbGxhYmxlT3B0aW9ucy5GZWVkRGV2aWNlc0VudHJ5EkQKDWZl",

"dGNoX2RldmljZXMYByADKAsyLS50ZW5zb3JmbG93LkNhbGxhYmxlT3B0aW9u",

"cy5GZXRjaERldmljZXNFbnRyeRIXCg9mZXRjaF9za2lwX3N5bmMYCCABKAga",

"MgoQRmVlZERldmljZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiAB",

"KAk6AjgBGjMKEUZldGNoRGV2aWNlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2",

"YWx1ZRgCIAEoCToCOAFChAEKGG9yZy50ZW5zb3JmbG93LmZyYW1ld29ya0IM",

"Q29uZmlnUHJvdG9zUAFaVWdpdGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3Jm",

"bG93L3RlbnNvcmZsb3cvZ28vY29yZS9wcm90b2J1Zi9mb3JfY29yZV9wcm90",

"b3NfZ29fcHJvdG/4AQFiBnByb3RvMw=="));

descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,

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

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

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", "DisallowRetryOnAllocationFailure" }, 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", "DeviceOrdinal" }, null, null, null, null)})}),

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

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),

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

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

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

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", "DisableFunctionalOpsLowering", "XlaPreferSingleGraphCluster", "CoordinationConfig" }, null, new[]{ typeof(global::Tensorflow.ConfigProto.Types.Experimental.Types.MlirBridgeRollout) }, null, null)}),

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)})}),

new pbr::GeneratedClrTypeInfo(typeof(global::Tensorflow.RunMetadata), global::Tensorflow.RunMetadata.Parser, new[]{ "StepStats", "CostGraph", "PartitionGraphs", "FunctionGraphs", "SessionMetadata" }, 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)}),

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

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, })

}));

}

#endregion

}

#region Messages

public sealed partial class GPUOptions : pb::IMessage<GPUOptions>

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

, pb::IBufferMessage

#endif

{

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

private pb::UnknownFieldSet _unknownFields;

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

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

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public static pbr::MessageDescriptor Descriptor {

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

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

pbr::MessageDescriptor pb::IMessage.Descriptor {

get { return Descriptor; }

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public GPUOptions() {

OnConstruction();

}

partial void OnConstruction();

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public GPUOptions(GPUOptions other) : this() {

perProcessGpuMemoryFraction_ = other.perProcessGpuMemoryFraction_;

allowGrowth_ = other.allowGrowth_;

allocatorType_ = other.allocatorType_;

deferredDeletionBytes_ = other.deferredDeletionBytes_;

visibleDeviceList_ = other.visibleDeviceList_;

pollingActiveDelayUsecs_ = other.pollingActiveDelayUsecs_;

pollingInactiveDelayMsecs_ = other.pollingInactiveDelayMsecs_;

forceGpuCompatible_ = other.forceGpuCompatible_;

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

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

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public GPUOptions Clone() {

return new GPUOptions(this);

}

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

public const int PerProcessGpuMemoryFractionFieldNumber = 1;

private double perProcessGpuMemoryFraction_;

/// <summary>

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

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

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

///

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

///

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

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

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

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

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

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

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

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

/// operating system. See

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

/// for the detailed requirements.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public double PerProcessGpuMemoryFraction {

get { return perProcessGpuMemoryFraction_; }

set {

perProcessGpuMemoryFraction_ = value;

}

}

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

public const int AllowGrowthFieldNumber = 4;

private bool allowGrowth_;

/// <summary>

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

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

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public bool AllowGrowth {

get { return allowGrowth_; }

set {

allowGrowth_ = value;

}

}

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

public const int AllocatorTypeFieldNumber = 2;

private string allocatorType_ = "";

/// <summary>

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

///

/// Allowed values:

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

/// which may change over time.

///

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

/// version of dlmalloc.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public string AllocatorType {

get { return allocatorType_; }

set {

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

}

}

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

public const int DeferredDeletionBytesFieldNumber = 3;

private long deferredDeletionBytes_;

/// <summary>

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

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

/// a reasonable default (several MBs).

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public long DeferredDeletionBytes {

get { return deferredDeletionBytes_; }

set {

deferredDeletionBytes_ = value;

}

}

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

public const int VisibleDeviceListFieldNumber = 5;

private string visibleDeviceList_ = "";

/// <summary>

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

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

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

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

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

/// spirit to the CUDA_VISIBLE_DEVICES environment variable, except

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

///

/// NOTE:

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

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

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

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

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

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

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

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

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

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

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

/// for more information.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public string VisibleDeviceList {

get { return visibleDeviceList_; }

set {

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

}

}

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

public const int PollingActiveDelayUsecsFieldNumber = 6;

private int pollingActiveDelayUsecs_;

/// <summary>

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

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

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

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public int PollingActiveDelayUsecs {

get { return pollingActiveDelayUsecs_; }

set {

pollingActiveDelayUsecs_ = value;

}

}

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

public const int PollingInactiveDelayMsecsFieldNumber = 7;

private int pollingInactiveDelayMsecs_;

/// <summary>

/// This field is deprecated and ignored.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public int PollingInactiveDelayMsecs {

get { return pollingInactiveDelayMsecs_; }

set {

pollingInactiveDelayMsecs_ = value;

}

}

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

public const int ForceGpuCompatibleFieldNumber = 8;

private bool forceGpuCompatible_;

/// <summary>

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

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

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

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

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

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

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

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

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

/// the overall host system performance.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public bool ForceGpuCompatible {

get { return forceGpuCompatible_; }

set {

forceGpuCompatible_ = value;

}

}

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

public const int ExperimentalFieldNumber = 9;

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

/// <summary>

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

/// to API stability guarantees in

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

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

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

get { return experimental_; }

set {

experimental_ = value;

}

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public override bool Equals(object other) {

return Equals(other as GPUOptions);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public bool Equals(GPUOptions other) {

if (ReferenceEquals(other, null)) {

return false;

}

if (ReferenceEquals(other, this)) {

return true;

}

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

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

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

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

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

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

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

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

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

return Equals(_unknownFields, other._unknownFields);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public override int GetHashCode() {

int hash = 1;

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

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

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

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

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

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

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

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

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

if (_unknownFields != null) {

hash ^= _unknownFields.GetHashCode();

}

return hash;

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public override string ToString() {

return pb::JsonFormatter.ToDiagnosticString(this);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public void WriteTo(pb::CodedOutputStream output) {

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

output.WriteRawMessage(this);

#else

if (PerProcessGpuMemoryFraction != 0D) {

output.WriteRawTag(9);

output.WriteDouble(PerProcessGpuMemoryFraction);

}

if (AllocatorType.Length != 0) {

output.WriteRawTag(18);

output.WriteString(AllocatorType);

}

if (DeferredDeletionBytes != 0L) {

output.WriteRawTag(24);

output.WriteInt64(DeferredDeletionBytes);

}

if (AllowGrowth != false) {

output.WriteRawTag(32);

output.WriteBool(AllowGrowth);

}

if (VisibleDeviceList.Length != 0) {

output.WriteRawTag(42);

output.WriteString(VisibleDeviceList);

}

if (PollingActiveDelayUsecs != 0) {

output.WriteRawTag(48);

output.WriteInt32(PollingActiveDelayUsecs);

}

if (PollingInactiveDelayMsecs != 0) {

output.WriteRawTag(56);

output.WriteInt32(PollingInactiveDelayMsecs);

}

if (ForceGpuCompatible != false) {

output.WriteRawTag(64);

output.WriteBool(ForceGpuCompatible);

}

if (experimental_ != null) {

output.WriteRawTag(74);

output.WriteMessage(Experimental);

}

if (_unknownFields != null) {

_unknownFields.WriteTo(output);

}

#endif

}

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {

if (PerProcessGpuMemoryFraction != 0D) {

output.WriteRawTag(9);

output.WriteDouble(PerProcessGpuMemoryFraction);

}

if (AllocatorType.Length != 0) {

output.WriteRawTag(18);

output.WriteString(AllocatorType);

}

if (DeferredDeletionBytes != 0L) {

output.WriteRawTag(24);

output.WriteInt64(DeferredDeletionBytes);

}

if (AllowGrowth != false) {

output.WriteRawTag(32);

output.WriteBool(AllowGrowth);

}

if (VisibleDeviceList.Length != 0) {

output.WriteRawTag(42);

output.WriteString(VisibleDeviceList);

}

if (PollingActiveDelayUsecs != 0) {

output.WriteRawTag(48);

output.WriteInt32(PollingActiveDelayUsecs);

}

if (PollingInactiveDelayMsecs != 0) {

output.WriteRawTag(56);

output.WriteInt32(PollingInactiveDelayMsecs);

}

if (ForceGpuCompatible != false) {

output.WriteRawTag(64);

output.WriteBool(ForceGpuCompatible);

}

if (experimental_ != null) {

output.WriteRawTag(74);

output.WriteMessage(Experimental);

}

if (_unknownFields != null) {

_unknownFields.WriteTo(ref output);

}

}

#endif

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public int CalculateSize() {

int size = 0;

if (PerProcessGpuMemoryFraction != 0D) {

size += 1 + 8;

}

if (AllowGrowth != false) {

size += 1 + 1;

}

if (AllocatorType.Length != 0) {

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

}

if (DeferredDeletionBytes != 0L) {

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

}

if (VisibleDeviceList.Length != 0) {

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

}

if (PollingActiveDelayUsecs != 0) {

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

}

if (PollingInactiveDelayMsecs != 0) {

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

}

if (ForceGpuCompatible != false) {

size += 1 + 1;

}

if (experimental_ != null) {

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

}

if (_unknownFields != null) {

size += _unknownFields.CalculateSize();

}

return size;

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public void MergeFrom(GPUOptions other) {

if (other == null) {

return;

}

if (other.PerProcessGpuMemoryFraction != 0D) {

PerProcessGpuMemoryFraction = other.PerProcessGpuMemoryFraction;

}

if (other.AllowGrowth != false) {

AllowGrowth = other.AllowGrowth;

}

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

AllocatorType = other.AllocatorType;

}

if (other.DeferredDeletionBytes != 0L) {

DeferredDeletionBytes = other.DeferredDeletionBytes;

}

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

VisibleDeviceList = other.VisibleDeviceList;

}

if (other.PollingActiveDelayUsecs != 0) {

PollingActiveDelayUsecs = other.PollingActiveDelayUsecs;

}

if (other.PollingInactiveDelayMsecs != 0) {

PollingInactiveDelayMsecs = other.PollingInactiveDelayMsecs;

}

if (other.ForceGpuCompatible != false) {

ForceGpuCompatible = other.ForceGpuCompatible;

}

if (other.experimental_ != null) {

if (experimental_ == null) {

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

}

Experimental.MergeFrom(other.Experimental);

}

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

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public void MergeFrom(pb::CodedInputStream input) {

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

input.ReadRawMessage(this);

#else

uint tag;

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

switch(tag) {

default:

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

break;

case 9: {

PerProcessGpuMemoryFraction = input.ReadDouble();

break;

}

case 18: {

AllocatorType = input.ReadString();

break;

}

case 24: {

DeferredDeletionBytes = input.ReadInt64();

break;

}

case 32: {

AllowGrowth = input.ReadBool();

break;

}

case 42: {

VisibleDeviceList = input.ReadString();

break;

}

case 48: {

PollingActiveDelayUsecs = input.ReadInt32();

break;

}

case 56: {

PollingInactiveDelayMsecs = input.ReadInt32();

break;

}

case 64: {

ForceGpuCompatible = input.ReadBool();

break;

}

case 74: {

if (experimental_ == null) {

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

}

input.ReadMessage(Experimental);

break;

}

}

}

#endif

}

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {

uint tag;

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

switch(tag) {

default:

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

break;

case 9: {

PerProcessGpuMemoryFraction = input.ReadDouble();

break;

}

case 18: {

AllocatorType = input.ReadString();

break;

}

case 24: {

DeferredDeletionBytes = input.ReadInt64();

break;

}

case 32: {

AllowGrowth = input.ReadBool();

break;

}

case 42: {

VisibleDeviceList = input.ReadString();

break;

}

case 48: {

PollingActiveDelayUsecs = input.ReadInt32();

break;

}

case 56: {

PollingInactiveDelayMsecs = input.ReadInt32();

break;

}

case 64: {

ForceGpuCompatible = input.ReadBool();

break;

}

case 74: {

if (experimental_ == null) {

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

}

input.ReadMessage(Experimental);

break;

}

}

}

}

#endif

#region Nested types

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

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public static partial class Types {

public sealed partial class Experimental : pb::IMessage<Experimental>

#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE

, pb::IBufferMessage

#endif

{

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

private pb::UnknownFieldSet _unknownFields;

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

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

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public static pbr::MessageDescriptor Descriptor {

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

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

pbr::MessageDescriptor pb::IMessage.Descriptor {

get { return Descriptor; }

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public Experimental() {

OnConstruction();

}

partial void OnConstruction();

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public Experimental(Experimental other) : this() {

virtualDevices_ = other.virtualDevices_.Clone();

useUnifiedMemory_ = other.useUnifiedMemory_;

numDevToDevCopyStreams_ = other.numDevToDevCopyStreams_;

collectiveRingOrder_ = other.collectiveRingOrder_;

timestampedAllocator_ = other.timestampedAllocator_;

kernelTrackerMaxInterval_ = other.kernelTrackerMaxInterval_;

kernelTrackerMaxBytes_ = other.kernelTrackerMaxBytes_;

kernelTrackerMaxPending_ = other.kernelTrackerMaxPending_;

internalFragmentationFraction_ = other.internalFragmentationFraction_;

useCudaMallocAsync_ = other.useCudaMallocAsync_;

disallowRetryOnAllocationFailure_ = other.disallowRetryOnAllocationFailure_;

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

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public Experimental Clone() {

return new Experimental(this);

}

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

public const int VirtualDevicesFieldNumber = 1;

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

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

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

/// <summary>

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

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

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

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

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

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

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

/// according to the order of the virtual devices determined by

/// device_ordinal and the location in the virtual device list.

///

/// For example,

/// visible_device_list = "1,0"

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

/// virtual_devices { memory_limit: 3GB memory_limit: 4GB }

/// will create 4 virtual devices as:

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

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

/// /device:GPU:2 -> visible GPU 0 with 3GB memory

/// /device:GPU:3 -> visible GPU 0 with 4GB memory

///

/// but

/// visible_device_list = "1,0"

/// virtual_devices { memory_limit: 1GB memory_limit: 2GB

/// device_ordinal: 10 device_ordinal: 20}

/// virtual_devices { memory_limit: 3GB memory_limit: 4GB

/// device_ordinal: 10 device_ordinal: 20}

/// will create 4 virtual devices as:

/// /device:GPU:0 -> visible GPU 1 with 1GB memory (ordinal 10)

/// /device:GPU:1 -> visible GPU 0 with 3GB memory (ordinal 10)

/// /device:GPU:2 -> visible GPU 1 with 2GB memory (ordinal 20)

/// /device:GPU:3 -> visible GPU 0 with 4GB memory (ordinal 20)

///

/// NOTE:

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

/// at the same time.

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

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

/// result in undefined behavior.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

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

get { return virtualDevices_; }

}

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

public const int UseUnifiedMemoryFieldNumber = 2;

private bool useUnifiedMemory_;

/// <summary>

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

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

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

/// per_process_gpu_memory_fraction field for more details and requirements

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

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

/// than 1.0 per process memory fraction.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public bool UseUnifiedMemory {

get { return useUnifiedMemory_; }

set {

useUnifiedMemory_ = value;

}

}

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

public const int NumDevToDevCopyStreamsFieldNumber = 3;

private int numDevToDevCopyStreams_;

/// <summary>

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

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

/// converted to 1.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public int NumDevToDevCopyStreams {

get { return numDevToDevCopyStreams_; }

set {

numDevToDevCopyStreams_ = value;

}

}

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

public const int CollectiveRingOrderFieldNumber = 4;

private string collectiveRingOrder_ = "";

/// <summary>

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

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

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

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

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

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

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public string CollectiveRingOrder {

get { return collectiveRingOrder_; }

set {

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

}

}

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

public const int TimestampedAllocatorFieldNumber = 5;

private bool timestampedAllocator_;

/// <summary>

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

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

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

/// is really not subject to pending use.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public bool TimestampedAllocator {

get { return timestampedAllocator_; }

set {

timestampedAllocator_ = value;

}

}

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

public const int KernelTrackerMaxIntervalFieldNumber = 7;

private int kernelTrackerMaxInterval_;

/// <summary>

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

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

/// specified.

///

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

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

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public int KernelTrackerMaxInterval {

get { return kernelTrackerMaxInterval_; }

set {

kernelTrackerMaxInterval_ = value;

}

}

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

public const int KernelTrackerMaxBytesFieldNumber = 8;

private int kernelTrackerMaxBytes_;

/// <summary>

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

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

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

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

/// the pending limit.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public int KernelTrackerMaxBytes {

get { return kernelTrackerMaxBytes_; }

set {

kernelTrackerMaxBytes_ = value;

}

}

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

public const int KernelTrackerMaxPendingFieldNumber = 9;

private int kernelTrackerMaxPending_;

/// <summary>

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

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

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

/// completes.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

[global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]

public int KernelTrackerMaxPending {

get { return kernelTrackerMaxPending_; }

set {

kernelTrackerMaxPending_ = value;

}

}

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

public const int InternalFragmentationFractionFieldNumber = 10;