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

"b3JlL3Byb3RvYnVmL3Jld3JpdGVyX2NvbmZpZy5wcm90byLJBQoKR1BVT3B0",

"aW9ucxInCh9wZXJfcHJvY2Vzc19ncHVfbWVtb3J5X2ZyYWN0aW9uGAEgASgB",

"EhQKDGFsbG93X2dyb3d0aBgEIAEoCBIWCg5hbGxvY2F0b3JfdHlwZRgCIAEo",

"CRIfChdkZWZlcnJlZF9kZWxldGlvbl9ieXRlcxgDIAEoAxIbChN2aXNpYmxl",

"X2RldmljZV9saXN0GAUgASgJEiIKGnBvbGxpbmdfYWN0aXZlX2RlbGF5X3Vz",

"ZWNzGAYgASgFEiQKHHBvbGxpbmdfaW5hY3RpdmVfZGVsYXlfbXNlY3MYByAB",

"KAUSHAoUZm9yY2VfZ3B1X2NvbXBhdGlibGUYCCABKAgSOQoMZXhwZXJpbWVu",

"dGFsGAkgASgLMiMudGVuc29yZmxvdy5HUFVPcHRpb25zLkV4cGVyaW1lbnRh",

"bBqCAwoMRXhwZXJpbWVudGFsEksKD3ZpcnR1YWxfZGV2aWNlcxgBIAMoCzIy",

"LnRlbnNvcmZsb3cuR1BVT3B0aW9ucy5FeHBlcmltZW50YWwuVmlydHVhbERl",

"dmljZXMSGgoSdXNlX3VuaWZpZWRfbWVtb3J5GAIgASgIEiMKG251bV9kZXZf",

"dG9fZGV2X2NvcHlfc3RyZWFtcxgDIAEoBRIdChVjb2xsZWN0aXZlX3Jpbmdf",

"b3JkZXIYBCABKAkSHQoVdGltZXN0YW1wZWRfYWxsb2NhdG9yGAUgASgIEiMK",

"G2tlcm5lbF90cmFja2VyX21heF9pbnRlcnZhbBgHIAEoBRIgChhrZXJuZWxf",

"dHJhY2tlcl9tYXhfYnl0ZXMYCCABKAUSIgoaa2VybmVsX3RyYWNrZXJfbWF4",

"X3BlbmRpbmcYCSABKAUaOwoOVmlydHVhbERldmljZXMSFwoPbWVtb3J5X2xp",

"bWl0X21iGAEgAygCEhAKCHByaW9yaXR5GAIgAygFIoUDChBPcHRpbWl6ZXJP",

"cHRpb25zEisKI2RvX2NvbW1vbl9zdWJleHByZXNzaW9uX2VsaW1pbmF0aW9u",

"GAEgASgIEhsKE2RvX2NvbnN0YW50X2ZvbGRpbmcYAiABKAgSJAocbWF4X2Zv",

"bGRlZF9jb25zdGFudF9pbl9ieXRlcxgGIAEoAxIcChRkb19mdW5jdGlvbl9p",

"bmxpbmluZxgEIAEoCBI1CglvcHRfbGV2ZWwYAyABKA4yIi50ZW5zb3JmbG93",

"Lk9wdGltaXplck9wdGlvbnMuTGV2ZWwSRQoQZ2xvYmFsX2ppdF9sZXZlbBgF",

"IAEoDjIrLnRlbnNvcmZsb3cuT3B0aW1pemVyT3B0aW9ucy5HbG9iYWxKaXRM",

"ZXZlbCIgCgVMZXZlbBIGCgJMMRAAEg8KAkwwEP///////////wEiQwoOR2xv",

"YmFsSml0TGV2ZWwSCwoHREVGQVVMVBAAEhAKA09GRhD///////////8BEggK",

"BE9OXzEQARIICgRPTl8yEAIi7gIKDEdyYXBoT3B0aW9ucxIeChZlbmFibGVf",

"cmVjdl9zY2hlZHVsaW5nGAIgASgIEjcKEW9wdGltaXplcl9vcHRpb25zGAMg",

"ASgLMhwudGVuc29yZmxvdy5PcHRpbWl6ZXJPcHRpb25zEhgKEGJ1aWxkX2Nv",

"c3RfbW9kZWwYBCABKAMSHgoWYnVpbGRfY29zdF9tb2RlbF9hZnRlchgJIAEo",

"AxIUCgxpbmZlcl9zaGFwZXMYBSABKAgSGgoScGxhY2VfcHJ1bmVkX2dyYXBo",

"GAYgASgIEiAKGGVuYWJsZV9iZmxvYXQxNl9zZW5kcmVjdhgHIAEoCBIVCg10",

"aW1lbGluZV9zdGVwGAggASgFEjMKD3Jld3JpdGVfb3B0aW9ucxgKIAEoCzIa",

"LnRlbnNvcmZsb3cuUmV3cml0ZXJDb25maWdKBAgBEAJSJXNraXBfY29tbW9u",

"X3N1YmV4cHJlc3Npb25fZWxpbWluYXRpb24iQQoVVGhyZWFkUG9vbE9wdGlv",

"blByb3RvEhMKC251bV90aHJlYWRzGAEgASgFEhMKC2dsb2JhbF9uYW1lGAIg",

"ASgJIrQBCgpSUENPcHRpb25zEiQKHHVzZV9ycGNfZm9yX2lucHJvY2Vzc19t",

"YXN0ZXIYASABKAgSHQoVY29tcHJlc3Npb25fYWxnb3JpdGhtGAIgASgJEhkK",

"EWNvbXByZXNzaW9uX2xldmVsGAMgASgFEhoKEmNhY2hlX3JwY19yZXNwb25z",

"ZRgEIAEoCBIqCiJkaXNhYmxlX3Nlc3Npb25fY29ubmVjdGlvbl9zaGFyaW5n",

"GAUgASgIIjAKD1Nlc3Npb25NZXRhZGF0YRIMCgRuYW1lGAEgASgJEg8KB3Zl",

"cnNpb24YAiABKAMijA0KC0NvbmZpZ1Byb3RvEj4KDGRldmljZV9jb3VudBgB",

"IAMoCzIoLnRlbnNvcmZsb3cuQ29uZmlnUHJvdG8uRGV2aWNlQ291bnRFbnRy",

"eRIkChxpbnRyYV9vcF9wYXJhbGxlbGlzbV90aHJlYWRzGAIgASgFEiQKHGlu",

"dGVyX29wX3BhcmFsbGVsaXNtX3RocmVhZHMYBSABKAUSHwoXdXNlX3Blcl9z",

"ZXNzaW9uX3RocmVhZHMYCSABKAgSRwocc2Vzc2lvbl9pbnRlcl9vcF90aHJl",

"YWRfcG9vbBgMIAMoCzIhLnRlbnNvcmZsb3cuVGhyZWFkUG9vbE9wdGlvblBy",

"b3RvEhgKEHBsYWNlbWVudF9wZXJpb2QYAyABKAUSFgoOZGV2aWNlX2ZpbHRl",

"cnMYBCADKAkSKwoLZ3B1X29wdGlvbnMYBiABKAsyFi50ZW5zb3JmbG93LkdQ",

"VU9wdGlvbnMSHAoUYWxsb3dfc29mdF9wbGFjZW1lbnQYByABKAgSHAoUbG9n",

"X2RldmljZV9wbGFjZW1lbnQYCCABKAgSLwoNZ3JhcGhfb3B0aW9ucxgKIAEo",

"CzIYLnRlbnNvcmZsb3cuR3JhcGhPcHRpb25zEh8KF29wZXJhdGlvbl90aW1l",

"b3V0X2luX21zGAsgASgDEisKC3JwY19vcHRpb25zGA0gASgLMhYudGVuc29y",

"Zmxvdy5SUENPcHRpb25zEisKC2NsdXN0ZXJfZGVmGA4gASgLMhYudGVuc29y",

"Zmxvdy5DbHVzdGVyRGVmEh0KFWlzb2xhdGVfc2Vzc2lvbl9zdGF0ZRgPIAEo",

"CBIoCiBzaGFyZV9jbHVzdGVyX2RldmljZXNfaW5fc2Vzc2lvbhgRIAEoCBI6",

"CgxleHBlcmltZW50YWwYECABKAsyJC50ZW5zb3JmbG93LkNvbmZpZ1Byb3Rv",

"LkV4cGVyaW1lbnRhbBoyChBEZXZpY2VDb3VudEVudHJ5EgsKA2tleRgBIAEo",

"CRINCgV2YWx1ZRgCIAEoBToCOAEahgcKDEV4cGVyaW1lbnRhbBIfChdjb2xs",

"ZWN0aXZlX2dyb3VwX2xlYWRlchgBIAEoCRIVCg1leGVjdXRvcl90eXBlGAMg",

"ASgJEhoKEnJlY3ZfYnVmX21heF9jaHVuaxgEIAEoBRIZChF1c2VfbnVtYV9h",

"ZmZpbml0eRgFIAEoCBI1Ci1jb2xsZWN0aXZlX2RldGVybWluaXN0aWNfc2Vx",

"dWVudGlhbF9leGVjdXRpb24YBiABKAgSFwoPY29sbGVjdGl2ZV9uY2NsGAcg",

"ASgIEjYKLnNoYXJlX3Nlc3Npb25fc3RhdGVfaW5fY2x1c3RlcnNwZWNfcHJv",

"cGFnYXRpb24YCCABKAgSHwoXZGlzYWJsZV90aHJlYWRfc3Bpbm5pbmcYCSAB",

"KAgSKAogc2hhcmVfY2x1c3Rlcl9kZXZpY2VzX2luX3Nlc3Npb24YCiABKAgS",

"NQoQc2Vzc2lvbl9tZXRhZGF0YRgLIAEoCzIbLnRlbnNvcmZsb3cuU2Vzc2lv",

"bk1ldGFkYXRhEiEKGW9wdGltaXplX2Zvcl9zdGF0aWNfZ3JhcGgYDCABKAgS",

"GgoSZW5hYmxlX21saXJfYnJpZGdlGA0gASgIElMKE21saXJfYnJpZGdlX3Jv",

"bGxvdXQYESABKA4yNi50ZW5zb3JmbG93LkNvbmZpZ1Byb3RvLkV4cGVyaW1l",

"bnRhbC5NbGlyQnJpZGdlUm9sbG91dBImCh5lbmFibGVfbWxpcl9ncmFwaF9v",

"cHRpbWl6YXRpb24YECABKAgSJwofZGlzYWJsZV9vdXRwdXRfcGFydGl0aW9u",

"X2dyYXBocxgOIAEoCBIjCht4bGFfZnVzaW9uX2F1dG90dW5lcl90aHJlc2gY",

"DyABKAMSEAoIdXNlX3RmcnQYEiABKAgi2gEKEU1saXJCcmlkZ2VSb2xsb3V0",

"EiMKH01MSVJfQlJJREdFX1JPTExPVVRfVU5TUEVDSUZJRUQQABIfChtNTElS",

"X0JSSURHRV9ST0xMT1VUX0VOQUJMRUQQARIgChxNTElSX0JSSURHRV9ST0xM",

"T1VUX0RJU0FCTEVEEAISKQolTUxJUl9CUklER0VfUk9MTE9VVF9TQUZFX01P",

"REVfRU5BQkxFRBADEjIKLk1MSVJfQlJJREdFX1JPTExPVVRfU0FGRV9NT0RF",

"X0ZBTExCQUNLX0VOQUJMRUQQBEoECAIQAyLhBAoKUnVuT3B0aW9ucxI2Cgt0",

"cmFjZV9sZXZlbBgBIAEoDjIhLnRlbnNvcmZsb3cuUnVuT3B0aW9ucy5UcmFj",

"ZUxldmVsEhUKDXRpbWVvdXRfaW5fbXMYAiABKAMSHAoUaW50ZXJfb3BfdGhy",

"ZWFkX3Bvb2wYAyABKAUSHwoXb3V0cHV0X3BhcnRpdGlvbl9ncmFwaHMYBSAB",

"KAgSLwoNZGVidWdfb3B0aW9ucxgGIAEoCzIYLnRlbnNvcmZsb3cuRGVidWdP",

"cHRpb25zEioKInJlcG9ydF90ZW5zb3JfYWxsb2NhdGlvbnNfdXBvbl9vb20Y",

"ByABKAgSOQoMZXhwZXJpbWVudGFsGAggASgLMiMudGVuc29yZmxvdy5SdW5P",

"cHRpb25zLkV4cGVyaW1lbnRhbBrSAQoMRXhwZXJpbWVudGFsEhwKFGNvbGxl",

"Y3RpdmVfZ3JhcGhfa2V5GAEgASgDEhwKFHVzZV9ydW5faGFuZGxlcl9wb29s",

"GAIgASgIElsKGHJ1bl9oYW5kbGVyX3Bvb2xfb3B0aW9ucxgDIAEoCzI5LnRl",

"bnNvcmZsb3cuUnVuT3B0aW9ucy5FeHBlcmltZW50YWwuUnVuSGFuZGxlclBv",

"b2xPcHRpb25zGikKFVJ1bkhhbmRsZXJQb29sT3B0aW9ucxIQCghwcmlvcml0",

"eRgBIAEoAyJSCgpUcmFjZUxldmVsEgwKCE5PX1RSQUNFEAASEgoOU09GVFdB",

"UkVfVFJBQ0UQARISCg5IQVJEV0FSRV9UUkFDRRACEg4KCkZVTExfVFJBQ0UQ",

"A0oECAQQBSKHAwoLUnVuTWV0YWRhdGESKQoKc3RlcF9zdGF0cxgBIAEoCzIV",

"LnRlbnNvcmZsb3cuU3RlcFN0YXRzEiwKCmNvc3RfZ3JhcGgYAiABKAsyGC50",

"ZW5zb3JmbG93LkNvc3RHcmFwaERlZhIuChBwYXJ0aXRpb25fZ3JhcGhzGAMg",

"AygLMhQudGVuc29yZmxvdy5HcmFwaERlZhI/Cg9mdW5jdGlvbl9ncmFwaHMY",

"BCADKAsyJi50ZW5zb3JmbG93LlJ1bk1ldGFkYXRhLkZ1bmN0aW9uR3JhcGhz",

"Gq0BCg5GdW5jdGlvbkdyYXBocxIuChBwYXJ0aXRpb25fZ3JhcGhzGAEgAygL",

"MhQudGVuc29yZmxvdy5HcmFwaERlZhI0ChZwcmVfb3B0aW1pemF0aW9uX2dy",

"YXBoGAIgASgLMhQudGVuc29yZmxvdy5HcmFwaERlZhI1Chdwb3N0X29wdGlt",

"aXphdGlvbl9ncmFwaBgDIAEoCzIULnRlbnNvcmZsb3cuR3JhcGhEZWYiOgoQ",

"VGVuc29yQ29ubmVjdGlvbhITCgtmcm9tX3RlbnNvchgBIAEoCRIRCgl0b190",

"ZW5zb3IYAiABKAkisAMKD0NhbGxhYmxlT3B0aW9ucxIMCgRmZWVkGAEgAygJ",

"Eg0KBWZldGNoGAIgAygJEg4KBnRhcmdldBgDIAMoCRIrCgtydW5fb3B0aW9u",

"cxgEIAEoCzIWLnRlbnNvcmZsb3cuUnVuT3B0aW9ucxI3ChF0ZW5zb3JfY29u",

"bmVjdGlvbhgFIAMoCzIcLnRlbnNvcmZsb3cuVGVuc29yQ29ubmVjdGlvbhJC",

"CgxmZWVkX2RldmljZXMYBiADKAsyLC50ZW5zb3JmbG93LkNhbGxhYmxlT3B0",

"aW9ucy5GZWVkRGV2aWNlc0VudHJ5EkQKDWZldGNoX2RldmljZXMYByADKAsy",

"LS50ZW5zb3JmbG93LkNhbGxhYmxlT3B0aW9ucy5GZXRjaERldmljZXNFbnRy",

"eRIXCg9mZXRjaF9za2lwX3N5bmMYCCABKAgaMgoQRmVlZERldmljZXNFbnRy",

"eRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBGjMKEUZldGNoRGV2",

"aWNlc0VudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoCToCOAFChAEK",

"GG9yZy50ZW5zb3JmbG93LmZyYW1ld29ya0IMQ29uZmlnUHJvdG9zUAFaVWdp",

"dGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3JmbG93L3RlbnNvcmZsb3cvZ28v",

"Y29yZS9wcm90b2J1Zi9mb3JfY29yZV9wcm90b3NfZ29fcHJvdG/4AQFiBnBy",

"b3RvMw=="));

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" }, 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" }, 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" }, 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_;

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

}

}

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

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

}

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

CollectiveRingOrder = other.CollectiveRingOrder;

}

if (other.TimestampedAllocator != false) {

TimestampedAllocator = other.TimestampedAllocator;

}

if (other.KernelTrackerMaxInterval != 0) {

KernelTrackerMaxInterval = other.KernelTrackerMaxInterval;

}

if (other.KernelTrackerMaxBytes != 0) {

KernelTrackerMaxBytes = other.KernelTrackerMaxBytes;

}

if (other.KernelTrackerMaxPending != 0) {

KernelTrackerMaxPending = other.KernelTrackerMaxPending;

}

_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 10: {

virtualDevices_.AddEntriesFrom(input, _repeated_virtualDevices_codec);

break;

}

case 16: {

UseUnifiedMemory = input.ReadBool();

break;

}

case 24: {

NumDevToDevCopyStreams = input.ReadInt32();

break;

}

case 34: {

CollectiveRingOrder = input.ReadString();

break;

}

case 40: {

TimestampedAllocator = input.ReadBool();

break;

}

case 56: {

KernelTrackerMaxInterval = input.ReadInt32();

break;

}

case 64: {

KernelTrackerMaxBytes = input.ReadInt32();

break;

}

case 72: {

KernelTrackerMaxPending = input.ReadInt32();

break;

}

}