// <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

#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",

"dGVuc29yZmxvdy9jb3JlL3Byb3RvYnVmL2NsdXN0ZXIucHJvdG8aJHRlbnNv",

"cmZsb3cvY29yZS9wcm90b2J1Zi9kZWJ1Zy5wcm90bxoudGVuc29yZmxvdy9j",

"b3JlL3Byb3RvYnVmL3Jld3JpdGVyX2NvbmZpZy5wcm90byKRBgoKR1BVT3B0",

"aW9ucxInCh9wZXJfcHJvY2Vzc19ncHVfbWVtb3J5X2ZyYWN0aW9uGAEgASgB",

"EhQKDGFsbG93X2dyb3d0aBgEIAEoCBIWCg5hbGxvY2F0b3JfdHlwZRgCIAEo",

"CRIfChdkZWZlcnJlZF9kZWxldGlvbl9ieXRlcxgDIAEoAxIbChN2aXNpYmxl",

"X2RldmljZV9saXN0GAUgASgJEiIKGnBvbGxpbmdfYWN0aXZlX2RlbGF5X3Vz",

"ZWNzGAYgASgFEiQKHHBvbGxpbmdfaW5hY3RpdmVfZGVsYXlfbXNlY3MYByAB",

"KAUSHAoUZm9yY2VfZ3B1X2NvbXBhdGlibGUYCCABKAgSOQoMZXhwZXJpbWVu",

"dGFsGAkgASgLMiMudGVuc29yZmxvdy5HUFVPcHRpb25zLkV4cGVyaW1lbnRh",

"bBrKAwoMRXhwZXJpbWVudGFsEksKD3ZpcnR1YWxfZGV2aWNlcxgBIAMoCzIy",

"LnRlbnNvcmZsb3cuR1BVT3B0aW9ucy5FeHBlcmltZW50YWwuVmlydHVhbERl",

"dmljZXMSGgoSdXNlX3VuaWZpZWRfbWVtb3J5GAIgASgIEiMKG251bV9kZXZf",

"dG9fZGV2X2NvcHlfc3RyZWFtcxgDIAEoBRIdChVjb2xsZWN0aXZlX3Jpbmdf",

"b3JkZXIYBCABKAkSHQoVdGltZXN0YW1wZWRfYWxsb2NhdG9yGAUgASgIEiMK",

"G2tlcm5lbF90cmFja2VyX21heF9pbnRlcnZhbBgHIAEoBRIgChhrZXJuZWxf",

"dHJhY2tlcl9tYXhfYnl0ZXMYCCABKAUSIgoaa2VybmVsX3RyYWNrZXJfbWF4",

"X3BlbmRpbmcYCSABKAUSJwofaW50ZXJuYWxfZnJhZ21lbnRhdGlvbl9mcmFj",

"dGlvbhgKIAEoARIdChV1c2VfY3VkYV9tYWxsb2NfYXN5bmMYCyABKAgaOwoO",

"VmlydHVhbERldmljZXMSFwoPbWVtb3J5X2xpbWl0X21iGAEgAygCEhAKCHBy",

"aW9yaXR5GAIgAygFIoUDChBPcHRpbWl6ZXJPcHRpb25zEisKI2RvX2NvbW1v",

"bl9zdWJleHByZXNzaW9uX2VsaW1pbmF0aW9uGAEgASgIEhsKE2RvX2NvbnN0",

"YW50X2ZvbGRpbmcYAiABKAgSJAocbWF4X2ZvbGRlZF9jb25zdGFudF9pbl9i",

"eXRlcxgGIAEoAxIcChRkb19mdW5jdGlvbl9pbmxpbmluZxgEIAEoCBI1Cglv",

"cHRfbGV2ZWwYAyABKA4yIi50ZW5zb3JmbG93Lk9wdGltaXplck9wdGlvbnMu",

"TGV2ZWwSRQoQZ2xvYmFsX2ppdF9sZXZlbBgFIAEoDjIrLnRlbnNvcmZsb3cu",

"T3B0aW1pemVyT3B0aW9ucy5HbG9iYWxKaXRMZXZlbCIgCgVMZXZlbBIGCgJM",

"MRAAEg8KAkwwEP///////////wEiQwoOR2xvYmFsSml0TGV2ZWwSCwoHREVG",

"QVVMVBAAEhAKA09GRhD///////////8BEggKBE9OXzEQARIICgRPTl8yEAIi",

"7gIKDEdyYXBoT3B0aW9ucxIeChZlbmFibGVfcmVjdl9zY2hlZHVsaW5nGAIg",

"ASgIEjcKEW9wdGltaXplcl9vcHRpb25zGAMgASgLMhwudGVuc29yZmxvdy5P",

"cHRpbWl6ZXJPcHRpb25zEhgKEGJ1aWxkX2Nvc3RfbW9kZWwYBCABKAMSHgoW",

"YnVpbGRfY29zdF9tb2RlbF9hZnRlchgJIAEoAxIUCgxpbmZlcl9zaGFwZXMY",

"BSABKAgSGgoScGxhY2VfcHJ1bmVkX2dyYXBoGAYgASgIEiAKGGVuYWJsZV9i",

"ZmxvYXQxNl9zZW5kcmVjdhgHIAEoCBIVCg10aW1lbGluZV9zdGVwGAggASgF",

"EjMKD3Jld3JpdGVfb3B0aW9ucxgKIAEoCzIaLnRlbnNvcmZsb3cuUmV3cml0",

"ZXJDb25maWdKBAgBEAJSJXNraXBfY29tbW9uX3N1YmV4cHJlc3Npb25fZWxp",

"bWluYXRpb24iQQoVVGhyZWFkUG9vbE9wdGlvblByb3RvEhMKC251bV90aHJl",

"YWRzGAEgASgFEhMKC2dsb2JhbF9uYW1lGAIgASgJItUBCgpSUENPcHRpb25z",

"EiQKHHVzZV9ycGNfZm9yX2lucHJvY2Vzc19tYXN0ZXIYASABKAgSHQoVY29t",

"cHJlc3Npb25fYWxnb3JpdGhtGAIgASgJEhkKEWNvbXByZXNzaW9uX2xldmVs",

"GAMgASgFEhoKEmNhY2hlX3JwY19yZXNwb25zZRgEIAEoCBIqCiJkaXNhYmxl",

"X3Nlc3Npb25fY29ubmVjdGlvbl9zaGFyaW5nGAUgASgIEh8KF251bV9jaGFu",

"bmVsc19wZXJfdGFyZ2V0GAYgASgFIjAKD1Nlc3Npb25NZXRhZGF0YRIMCgRu",

"YW1lGAEgASgJEg8KB3ZlcnNpb24YAiABKAMi2A0KC0NvbmZpZ1Byb3RvEj4K",

"DGRldmljZV9jb3VudBgBIAMoCzIoLnRlbnNvcmZsb3cuQ29uZmlnUHJvdG8u",

"RGV2aWNlQ291bnRFbnRyeRIkChxpbnRyYV9vcF9wYXJhbGxlbGlzbV90aHJl",

"YWRzGAIgASgFEiQKHGludGVyX29wX3BhcmFsbGVsaXNtX3RocmVhZHMYBSAB",

"KAUSHwoXdXNlX3Blcl9zZXNzaW9uX3RocmVhZHMYCSABKAgSRwocc2Vzc2lv",

"bl9pbnRlcl9vcF90aHJlYWRfcG9vbBgMIAMoCzIhLnRlbnNvcmZsb3cuVGhy",

"ZWFkUG9vbE9wdGlvblByb3RvEhgKEHBsYWNlbWVudF9wZXJpb2QYAyABKAUS",

"FgoOZGV2aWNlX2ZpbHRlcnMYBCADKAkSKwoLZ3B1X29wdGlvbnMYBiABKAsy",

"Fi50ZW5zb3JmbG93LkdQVU9wdGlvbnMSHAoUYWxsb3dfc29mdF9wbGFjZW1l",

"bnQYByABKAgSHAoUbG9nX2RldmljZV9wbGFjZW1lbnQYCCABKAgSLwoNZ3Jh",

"cGhfb3B0aW9ucxgKIAEoCzIYLnRlbnNvcmZsb3cuR3JhcGhPcHRpb25zEh8K",

"F29wZXJhdGlvbl90aW1lb3V0X2luX21zGAsgASgDEisKC3JwY19vcHRpb25z",

"GA0gASgLMhYudGVuc29yZmxvdy5SUENPcHRpb25zEisKC2NsdXN0ZXJfZGVm",

"GA4gASgLMhYudGVuc29yZmxvdy5DbHVzdGVyRGVmEh0KFWlzb2xhdGVfc2Vz",

"c2lvbl9zdGF0ZRgPIAEoCBIoCiBzaGFyZV9jbHVzdGVyX2RldmljZXNfaW5f",

"c2Vzc2lvbhgRIAEoCBI6CgxleHBlcmltZW50YWwYECABKAsyJC50ZW5zb3Jm",

"bG93LkNvbmZpZ1Byb3RvLkV4cGVyaW1lbnRhbBoyChBEZXZpY2VDb3VudEVu",

"dHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoBToCOAEa0gcKDEV4cGVy",

"aW1lbnRhbBIfChdjb2xsZWN0aXZlX2dyb3VwX2xlYWRlchgBIAEoCRIVCg1l",

"eGVjdXRvcl90eXBlGAMgASgJEhoKEnJlY3ZfYnVmX21heF9jaHVuaxgEIAEo",

"BRIZChF1c2VfbnVtYV9hZmZpbml0eRgFIAEoCBI1Ci1jb2xsZWN0aXZlX2Rl",

"dGVybWluaXN0aWNfc2VxdWVudGlhbF9leGVjdXRpb24YBiABKAgSFwoPY29s",

"bGVjdGl2ZV9uY2NsGAcgASgIEjYKLnNoYXJlX3Nlc3Npb25fc3RhdGVfaW5f",

"Y2x1c3RlcnNwZWNfcHJvcGFnYXRpb24YCCABKAgSHwoXZGlzYWJsZV90aHJl",

"YWRfc3Bpbm5pbmcYCSABKAgSKAogc2hhcmVfY2x1c3Rlcl9kZXZpY2VzX2lu",

"X3Nlc3Npb24YCiABKAgSNQoQc2Vzc2lvbl9tZXRhZGF0YRgLIAEoCzIbLnRl",

"bnNvcmZsb3cuU2Vzc2lvbk1ldGFkYXRhEiEKGW9wdGltaXplX2Zvcl9zdGF0",

"aWNfZ3JhcGgYDCABKAgSGgoSZW5hYmxlX21saXJfYnJpZGdlGA0gASgIElMK",

"E21saXJfYnJpZGdlX3JvbGxvdXQYESABKA4yNi50ZW5zb3JmbG93LkNvbmZp",

"Z1Byb3RvLkV4cGVyaW1lbnRhbC5NbGlyQnJpZGdlUm9sbG91dBImCh5lbmFi",

"bGVfbWxpcl9ncmFwaF9vcHRpbWl6YXRpb24YECABKAgSJwofZGlzYWJsZV9v",

"dXRwdXRfcGFydGl0aW9uX2dyYXBocxgOIAEoCBIjCht4bGFfZnVzaW9uX2F1",

"dG90dW5lcl90aHJlc2gYDyABKAMSEAoIdXNlX3RmcnQYEiABKAgSHAoUY29v",

"cmRpbmF0aW9uX3NlcnZpY2UYEyABKAkSLAokZmV0Y2hfcmVtb3RlX2Rldmlj",

"ZXNfaW5fbXVsdGlfY2xpZW50GBQgASgIItoBChFNbGlyQnJpZGdlUm9sbG91",

"dBIjCh9NTElSX0JSSURHRV9ST0xMT1VUX1VOU1BFQ0lGSUVEEAASHwobTUxJ",

"Ul9CUklER0VfUk9MTE9VVF9FTkFCTEVEEAESIAocTUxJUl9CUklER0VfUk9M",

"TE9VVF9ESVNBQkxFRBACEikKJU1MSVJfQlJJREdFX1JPTExPVVRfU0FGRV9N",

"T0RFX0VOQUJMRUQQAxIyCi5NTElSX0JSSURHRV9ST0xMT1VUX1NBRkVfTU9E",

"RV9GQUxMQkFDS19FTkFCTEVEEARKBAgCEAMi4QQKClJ1bk9wdGlvbnMSNgoL",

"dHJhY2VfbGV2ZWwYASABKA4yIS50ZW5zb3JmbG93LlJ1bk9wdGlvbnMuVHJh",

"Y2VMZXZlbBIVCg10aW1lb3V0X2luX21zGAIgASgDEhwKFGludGVyX29wX3Ro",

"cmVhZF9wb29sGAMgASgFEh8KF291dHB1dF9wYXJ0aXRpb25fZ3JhcGhzGAUg",

"ASgIEi8KDWRlYnVnX29wdGlvbnMYBiABKAsyGC50ZW5zb3JmbG93LkRlYnVn",

"T3B0aW9ucxIqCiJyZXBvcnRfdGVuc29yX2FsbG9jYXRpb25zX3Vwb25fb29t",

"GAcgASgIEjkKDGV4cGVyaW1lbnRhbBgIIAEoCzIjLnRlbnNvcmZsb3cuUnVu",

"T3B0aW9ucy5FeHBlcmltZW50YWwa0gEKDEV4cGVyaW1lbnRhbBIcChRjb2xs",

"ZWN0aXZlX2dyYXBoX2tleRgBIAEoAxIcChR1c2VfcnVuX2hhbmRsZXJfcG9v",

"bBgCIAEoCBJbChhydW5faGFuZGxlcl9wb29sX29wdGlvbnMYAyABKAsyOS50",

"ZW5zb3JmbG93LlJ1bk9wdGlvbnMuRXhwZXJpbWVudGFsLlJ1bkhhbmRsZXJQ",

"b29sT3B0aW9ucxopChVSdW5IYW5kbGVyUG9vbE9wdGlvbnMSEAoIcHJpb3Jp",

"dHkYASABKAMiUgoKVHJhY2VMZXZlbBIMCghOT19UUkFDRRAAEhIKDlNPRlRX",

"QVJFX1RSQUNFEAESEgoOSEFSRFdBUkVfVFJBQ0UQAhIOCgpGVUxMX1RSQUNF",

"EANKBAgEEAUihwMKC1J1bk1ldGFkYXRhEikKCnN0ZXBfc3RhdHMYASABKAsy",

"FS50ZW5zb3JmbG93LlN0ZXBTdGF0cxIsCgpjb3N0X2dyYXBoGAIgASgLMhgu",

"dGVuc29yZmxvdy5Db3N0R3JhcGhEZWYSLgoQcGFydGl0aW9uX2dyYXBocxgD",

"IAMoCzIULnRlbnNvcmZsb3cuR3JhcGhEZWYSPwoPZnVuY3Rpb25fZ3JhcGhz",

"GAQgAygLMiYudGVuc29yZmxvdy5SdW5NZXRhZGF0YS5GdW5jdGlvbkdyYXBo",

"cxqtAQoORnVuY3Rpb25HcmFwaHMSLgoQcGFydGl0aW9uX2dyYXBocxgBIAMo",

"CzIULnRlbnNvcmZsb3cuR3JhcGhEZWYSNAoWcHJlX29wdGltaXphdGlvbl9n",

"cmFwaBgCIAEoCzIULnRlbnNvcmZsb3cuR3JhcGhEZWYSNQoXcG9zdF9vcHRp",

"bWl6YXRpb25fZ3JhcGgYAyABKAsyFC50ZW5zb3JmbG93LkdyYXBoRGVmIjoK",

"EFRlbnNvckNvbm5lY3Rpb24SEwoLZnJvbV90ZW5zb3IYASABKAkSEQoJdG9f",

"dGVuc29yGAIgASgJIrADCg9DYWxsYWJsZU9wdGlvbnMSDAoEZmVlZBgBIAMo",

"CRINCgVmZXRjaBgCIAMoCRIOCgZ0YXJnZXQYAyADKAkSKwoLcnVuX29wdGlv",

"bnMYBCABKAsyFi50ZW5zb3JmbG93LlJ1bk9wdGlvbnMSNwoRdGVuc29yX2Nv",

"bm5lY3Rpb24YBSADKAsyHC50ZW5zb3JmbG93LlRlbnNvckNvbm5lY3Rpb24S",

"QgoMZmVlZF9kZXZpY2VzGAYgAygLMiwudGVuc29yZmxvdy5DYWxsYWJsZU9w",

"dGlvbnMuRmVlZERldmljZXNFbnRyeRJECg1mZXRjaF9kZXZpY2VzGAcgAygL",

"Mi0udGVuc29yZmxvdy5DYWxsYWJsZU9wdGlvbnMuRmV0Y2hEZXZpY2VzRW50",

"cnkSFwoPZmV0Y2hfc2tpcF9zeW5jGAggASgIGjIKEEZlZWREZXZpY2VzRW50",

"cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ARozChFGZXRjaERl",

"dmljZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBQoQB",

"ChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCDENvbmZpZ1Byb3Rvc1ABWlVn",

"aXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90ZW5zb3JmbG93L2dv",

"L2NvcmUvcHJvdG9idWYvZm9yX2NvcmVfcHJvdG9zX2dvX3Byb3Rv+AEBYgZw",

"cm90bzM="));

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

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

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", "CoordinationService", "FetchRemoteDevicesInMultiClient" }, 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" }, 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> {

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

private pb::UnknownFieldSet _unknownFields;

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

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

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public static pbr::MessageDescriptor Descriptor {

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

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

pbr::MessageDescriptor pb::IMessage.Descriptor {

get { return Descriptor; }

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public GPUOptions() {

OnConstruction();

}

partial void OnConstruction();

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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

get { return experimental_; }

set {

experimental_ = value;

}

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public override bool Equals(object other) {

return Equals(other as GPUOptions);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

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]

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]

public override string ToString() {

return pb::JsonFormatter.ToDiagnosticString(this);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public void WriteTo(pb::CodedOutputStream 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(output);

}

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

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]

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]

public void MergeFrom(pb::CodedInputStream input) {

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;

}

}

}

}

#region Nested types

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

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public static partial class Types {

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

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

private pb::UnknownFieldSet _unknownFields;

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

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

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public static pbr::MessageDescriptor Descriptor {

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

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

pbr::MessageDescriptor pb::IMessage.Descriptor {

get { return Descriptor; }

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public Experimental() {

OnConstruction();

}

partial void OnConstruction();

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

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_;

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

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

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 they appear in this list and the "memory_limit"

/// list inside each element. For example,

/// visible_device_list = "1,0"

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

/// virtual_devices {}

/// will create three 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 all available memory

///

/// 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]

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]

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]

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]

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]

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]

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]

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]

public int KernelTrackerMaxPending {

get { return kernelTrackerMaxPending_; }

set {

kernelTrackerMaxPending_ = value;

}

}

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

public const int InternalFragmentationFractionFieldNumber = 10;

private double internalFragmentationFraction_;

/// <summary>

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

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

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

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

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

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

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

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

/// memory size.

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public double InternalFragmentationFraction {

get { return internalFragmentationFraction_; }

set {

internalFragmentationFraction_ = value;

}

}

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

public const int UseCudaMallocAsyncFieldNumber = 11;

private bool useCudaMallocAsync_;

/// <summary>

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

/// </summary>

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public bool UseCudaMallocAsync {

get { return useCudaMallocAsync_; }

set {

useCudaMallocAsync_ = value;

}

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public override bool Equals(object other) {

return Equals(other as Experimental);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public bool Equals(Experimental other) {

if (ReferenceEquals(other, null)) {

return false;

}

if (ReferenceEquals(other, this)) {

return true;

}

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

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

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

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

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

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

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

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

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

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

return Equals(_unknownFields, other._unknownFields);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public override int GetHashCode() {

int hash = 1;

hash ^= virtualDevices_.GetHashCode();

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

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

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

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

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

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

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

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

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

if (_unknownFields != null) {

hash ^= _unknownFields.GetHashCode();

}

return hash;

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public override string ToString() {

return pb::JsonFormatter.ToDiagnosticString(this);

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public void WriteTo(pb::CodedOutputStream output) {

virtualDevices_.WriteTo(output, _repeated_virtualDevices_codec);

if (UseUnifiedMemory != false) {

output.WriteRawTag(16);

output.WriteBool(UseUnifiedMemory);

}

if (NumDevToDevCopyStreams != 0) {

output.WriteRawTag(24);

output.WriteInt32(NumDevToDevCopyStreams);

}

if (CollectiveRingOrder.Length != 0) {

output.WriteRawTag(34);

output.WriteString(CollectiveRingOrder);

}

if (TimestampedAllocator != false) {

output.WriteRawTag(40);

output.WriteBool(TimestampedAllocator);

}

if (KernelTrackerMaxInterval != 0) {

output.WriteRawTag(56);

output.WriteInt32(KernelTrackerMaxInterval);

}

if (KernelTrackerMaxBytes != 0) {

output.WriteRawTag(64);

output.WriteInt32(KernelTrackerMaxBytes);

}

if (KernelTrackerMaxPending != 0) {

output.WriteRawTag(72);

output.WriteInt32(KernelTrackerMaxPending);

}

if (InternalFragmentationFraction != 0D) {

output.WriteRawTag(81);

output.WriteDouble(InternalFragmentationFraction);

}

if (UseCudaMallocAsync != false) {

output.WriteRawTag(88);

output.WriteBool(UseCudaMallocAsync);

}

if (_unknownFields != null) {

_unknownFields.WriteTo(output);

}

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public int CalculateSize() {

int size = 0;

size += virtualDevices_.CalculateSize(_repeated_virtualDevices_codec);

if (UseUnifiedMemory != false) {

size += 1 + 1;

}

if (NumDevToDevCopyStreams != 0) {

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

}

if (CollectiveRingOrder.Length != 0) {

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

}

if (TimestampedAllocator != false) {

size += 1 + 1;

}

if (KernelTrackerMaxInterval != 0) {

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

}

if (KernelTrackerMaxBytes != 0) {

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

}

if (KernelTrackerMaxPending != 0) {

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

}

if (InternalFragmentationFraction != 0D) {

size += 1 + 8;

}

if (UseCudaMallocAsync != false) {

size += 1 + 1;

}

if (_unknownFields != null) {

size += _unknownFields.CalculateSize();

}

return size;

}

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public void MergeFrom(Experimental other) {

if (other == null) {

return;

}

virtualDevices_.Add(other.virtualDevices_);

if (other.UseUnifiedMemory != false) {

UseUnifiedMemory = other.UseUnifiedMemory;

}

if (other.NumDevToDevCopyStreams != 0) {

NumDevToDevCopyStreams = other.NumDevToDevCopyStreams;