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

"b3JlL3Byb3RvYnVmL3Jld3JpdGVyX2NvbmZpZy5wcm90byK3BQoKR1BVT3B0",

"aW9ucxInCh9wZXJfcHJvY2Vzc19ncHVfbWVtb3J5X2ZyYWN0aW9uGAEgASgB",

"EhQKDGFsbG93X2dyb3d0aBgEIAEoCBIWCg5hbGxvY2F0b3JfdHlwZRgCIAEo",

"CRIfChdkZWZlcnJlZF9kZWxldGlvbl9ieXRlcxgDIAEoAxIbChN2aXNpYmxl",

"X2RldmljZV9saXN0GAUgASgJEiIKGnBvbGxpbmdfYWN0aXZlX2RlbGF5X3Vz",

"ZWNzGAYgASgFEiQKHHBvbGxpbmdfaW5hY3RpdmVfZGVsYXlfbXNlY3MYByAB",

"KAUSHAoUZm9yY2VfZ3B1X2NvbXBhdGlibGUYCCABKAgSOQoMZXhwZXJpbWVu",

"dGFsGAkgASgLMiMudGVuc29yZmxvdy5HUFVPcHRpb25zLkV4cGVyaW1lbnRh",

"bBrwAgoMRXhwZXJpbWVudGFsEksKD3ZpcnR1YWxfZGV2aWNlcxgBIAMoCzIy",

"LnRlbnNvcmZsb3cuR1BVT3B0aW9ucy5FeHBlcmltZW50YWwuVmlydHVhbERl",

"dmljZXMSGgoSdXNlX3VuaWZpZWRfbWVtb3J5GAIgASgIEiMKG251bV9kZXZf",

"dG9fZGV2X2NvcHlfc3RyZWFtcxgDIAEoBRIdChVjb2xsZWN0aXZlX3Jpbmdf",

"b3JkZXIYBCABKAkSHQoVdGltZXN0YW1wZWRfYWxsb2NhdG9yGAUgASgIEiMK",

"G2tlcm5lbF90cmFja2VyX21heF9pbnRlcnZhbBgHIAEoBRIgChhrZXJuZWxf",

"dHJhY2tlcl9tYXhfYnl0ZXMYCCABKAUSIgoaa2VybmVsX3RyYWNrZXJfbWF4",

"X3BlbmRpbmcYCSABKAUaKQoOVmlydHVhbERldmljZXMSFwoPbWVtb3J5X2xp",

"bWl0X21iGAEgAygCIoUDChBPcHRpbWl6ZXJPcHRpb25zEisKI2RvX2NvbW1v",

"bl9zdWJleHByZXNzaW9uX2VsaW1pbmF0aW9uGAEgASgIEhsKE2RvX2NvbnN0",

"YW50X2ZvbGRpbmcYAiABKAgSJAocbWF4X2ZvbGRlZF9jb25zdGFudF9pbl9i",

"eXRlcxgGIAEoAxIcChRkb19mdW5jdGlvbl9pbmxpbmluZxgEIAEoCBI1Cglv",

"cHRfbGV2ZWwYAyABKA4yIi50ZW5zb3JmbG93Lk9wdGltaXplck9wdGlvbnMu",

"TGV2ZWwSRQoQZ2xvYmFsX2ppdF9sZXZlbBgFIAEoDjIrLnRlbnNvcmZsb3cu",

"T3B0aW1pemVyT3B0aW9ucy5HbG9iYWxKaXRMZXZlbCIgCgVMZXZlbBIGCgJM",

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

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

"7gIKDEdyYXBoT3B0aW9ucxIeChZlbmFibGVfcmVjdl9zY2hlZHVsaW5nGAIg",

"ASgIEjcKEW9wdGltaXplcl9vcHRpb25zGAMgASgLMhwudGVuc29yZmxvdy5P",

"cHRpbWl6ZXJPcHRpb25zEhgKEGJ1aWxkX2Nvc3RfbW9kZWwYBCABKAMSHgoW",

"YnVpbGRfY29zdF9tb2RlbF9hZnRlchgJIAEoAxIUCgxpbmZlcl9zaGFwZXMY",

"BSABKAgSGgoScGxhY2VfcHJ1bmVkX2dyYXBoGAYgASgIEiAKGGVuYWJsZV9i",

"ZmxvYXQxNl9zZW5kcmVjdhgHIAEoCBIVCg10aW1lbGluZV9zdGVwGAggASgF",

"EjMKD3Jld3JpdGVfb3B0aW9ucxgKIAEoCzIaLnRlbnNvcmZsb3cuUmV3cml0",

"ZXJDb25maWdKBAgBEAJSJXNraXBfY29tbW9uX3N1YmV4cHJlc3Npb25fZWxp",

"bWluYXRpb24iQQoVVGhyZWFkUG9vbE9wdGlvblByb3RvEhMKC251bV90aHJl",

"YWRzGAEgASgFEhMKC2dsb2JhbF9uYW1lGAIgASgJIrQBCgpSUENPcHRpb25z",

"EiQKHHVzZV9ycGNfZm9yX2lucHJvY2Vzc19tYXN0ZXIYASABKAgSHQoVY29t",

"cHJlc3Npb25fYWxnb3JpdGhtGAIgASgJEhkKEWNvbXByZXNzaW9uX2xldmVs",

"GAMgASgFEhoKEmNhY2hlX3JwY19yZXNwb25zZRgEIAEoCBIqCiJkaXNhYmxl",

"X3Nlc3Npb25fY29ubmVjdGlvbl9zaGFyaW5nGAUgASgIIjAKD1Nlc3Npb25N",

"ZXRhZGF0YRIMCgRuYW1lGAEgASgJEg8KB3ZlcnNpb24YAiABKAMi9gkKC0Nv",

"bmZpZ1Byb3RvEj4KDGRldmljZV9jb3VudBgBIAMoCzIoLnRlbnNvcmZsb3cu",

"Q29uZmlnUHJvdG8uRGV2aWNlQ291bnRFbnRyeRIkChxpbnRyYV9vcF9wYXJh",

"bGxlbGlzbV90aHJlYWRzGAIgASgFEiQKHGludGVyX29wX3BhcmFsbGVsaXNt",

"X3RocmVhZHMYBSABKAUSHwoXdXNlX3Blcl9zZXNzaW9uX3RocmVhZHMYCSAB",

"KAgSRwocc2Vzc2lvbl9pbnRlcl9vcF90aHJlYWRfcG9vbBgMIAMoCzIhLnRl",

"bnNvcmZsb3cuVGhyZWFkUG9vbE9wdGlvblByb3RvEhgKEHBsYWNlbWVudF9w",

"ZXJpb2QYAyABKAUSFgoOZGV2aWNlX2ZpbHRlcnMYBCADKAkSKwoLZ3B1X29w",

"dGlvbnMYBiABKAsyFi50ZW5zb3JmbG93LkdQVU9wdGlvbnMSHAoUYWxsb3df",

"c29mdF9wbGFjZW1lbnQYByABKAgSHAoUbG9nX2RldmljZV9wbGFjZW1lbnQY",

"CCABKAgSLwoNZ3JhcGhfb3B0aW9ucxgKIAEoCzIYLnRlbnNvcmZsb3cuR3Jh",

"cGhPcHRpb25zEh8KF29wZXJhdGlvbl90aW1lb3V0X2luX21zGAsgASgDEisK",

"C3JwY19vcHRpb25zGA0gASgLMhYudGVuc29yZmxvdy5SUENPcHRpb25zEisK",

"C2NsdXN0ZXJfZGVmGA4gASgLMhYudGVuc29yZmxvdy5DbHVzdGVyRGVmEh0K",

"FWlzb2xhdGVfc2Vzc2lvbl9zdGF0ZRgPIAEoCBI6CgxleHBlcmltZW50YWwY",

"ECABKAsyJC50ZW5zb3JmbG93LkNvbmZpZ1Byb3RvLkV4cGVyaW1lbnRhbBoy",

"ChBEZXZpY2VDb3VudEVudHJ5EgsKA2tleRgBIAEoCRINCgV2YWx1ZRgCIAEo",

"BToCOAEamgQKDEV4cGVyaW1lbnRhbBIfChdjb2xsZWN0aXZlX2dyb3VwX2xl",

"YWRlchgBIAEoCRIVCg1leGVjdXRvcl90eXBlGAMgASgJEhoKEnJlY3ZfYnVm",

"X21heF9jaHVuaxgEIAEoBRIZChF1c2VfbnVtYV9hZmZpbml0eRgFIAEoCBI1",

"Ci1jb2xsZWN0aXZlX2RldGVybWluaXN0aWNfc2VxdWVudGlhbF9leGVjdXRp",

"b24YBiABKAgSFwoPY29sbGVjdGl2ZV9uY2NsGAcgASgIEjYKLnNoYXJlX3Nl",

"c3Npb25fc3RhdGVfaW5fY2x1c3RlcnNwZWNfcHJvcGFnYXRpb24YCCABKAgS",

"HwoXZGlzYWJsZV90aHJlYWRfc3Bpbm5pbmcYCSABKAgSKAogc2hhcmVfY2x1",

"c3Rlcl9kZXZpY2VzX2luX3Nlc3Npb24YCiABKAgSNQoQc2Vzc2lvbl9tZXRh",

"ZGF0YRgLIAEoCzIbLnRlbnNvcmZsb3cuU2Vzc2lvbk1ldGFkYXRhEiEKGW9w",

"dGltaXplX2Zvcl9zdGF0aWNfZ3JhcGgYDCABKAgSGgoSZW5hYmxlX21saXJf",

"YnJpZGdlGA0gASgIEicKH2Rpc2FibGVfb3V0cHV0X3BhcnRpdGlvbl9ncmFw",

"aHMYDiABKAgSIwobeGxhX2Z1c2lvbl9hdXRvdHVuZXJfdGhyZXNoGA8gASgD",

"SgQIAhADItgDCgpSdW5PcHRpb25zEjYKC3RyYWNlX2xldmVsGAEgASgOMiEu",

"dGVuc29yZmxvdy5SdW5PcHRpb25zLlRyYWNlTGV2ZWwSFQoNdGltZW91dF9p",

"bl9tcxgCIAEoAxIcChRpbnRlcl9vcF90aHJlYWRfcG9vbBgDIAEoBRIfChdv",

"dXRwdXRfcGFydGl0aW9uX2dyYXBocxgFIAEoCBIvCg1kZWJ1Z19vcHRpb25z",

"GAYgASgLMhgudGVuc29yZmxvdy5EZWJ1Z09wdGlvbnMSKgoicmVwb3J0X3Rl",

"bnNvcl9hbGxvY2F0aW9uc191cG9uX29vbRgHIAEoCBI5CgxleHBlcmltZW50",

"YWwYCCABKAsyIy50ZW5zb3JmbG93LlJ1bk9wdGlvbnMuRXhwZXJpbWVudGFs",

"GkoKDEV4cGVyaW1lbnRhbBIcChRjb2xsZWN0aXZlX2dyYXBoX2tleRgBIAEo",

"AxIcChR1c2VfcnVuX2hhbmRsZXJfcG9vbBgCIAEoCCJSCgpUcmFjZUxldmVs",

"EgwKCE5PX1RSQUNFEAASEgoOU09GVFdBUkVfVFJBQ0UQARISCg5IQVJEV0FS",

"RV9UUkFDRRACEg4KCkZVTExfVFJBQ0UQA0oECAQQBSKHAwoLUnVuTWV0YWRh",

"dGESKQoKc3RlcF9zdGF0cxgBIAEoCzIVLnRlbnNvcmZsb3cuU3RlcFN0YXRz",

"EiwKCmNvc3RfZ3JhcGgYAiABKAsyGC50ZW5zb3JmbG93LkNvc3RHcmFwaERl",

"ZhIuChBwYXJ0aXRpb25fZ3JhcGhzGAMgAygLMhQudGVuc29yZmxvdy5HcmFw",

"aERlZhI/Cg9mdW5jdGlvbl9ncmFwaHMYBCADKAsyJi50ZW5zb3JmbG93LlJ1",

"bk1ldGFkYXRhLkZ1bmN0aW9uR3JhcGhzGq0BCg5GdW5jdGlvbkdyYXBocxIu",

"ChBwYXJ0aXRpb25fZ3JhcGhzGAEgAygLMhQudGVuc29yZmxvdy5HcmFwaERl",

"ZhI0ChZwcmVfb3B0aW1pemF0aW9uX2dyYXBoGAIgASgLMhQudGVuc29yZmxv",

"dy5HcmFwaERlZhI1Chdwb3N0X29wdGltaXphdGlvbl9ncmFwaBgDIAEoCzIU",

"LnRlbnNvcmZsb3cuR3JhcGhEZWYiOgoQVGVuc29yQ29ubmVjdGlvbhITCgtm",

"cm9tX3RlbnNvchgBIAEoCRIRCgl0b190ZW5zb3IYAiABKAkisAMKD0NhbGxh",

"YmxlT3B0aW9ucxIMCgRmZWVkGAEgAygJEg0KBWZldGNoGAIgAygJEg4KBnRh",

"cmdldBgDIAMoCRIrCgtydW5fb3B0aW9ucxgEIAEoCzIWLnRlbnNvcmZsb3cu",

"UnVuT3B0aW9ucxI3ChF0ZW5zb3JfY29ubmVjdGlvbhgFIAMoCzIcLnRlbnNv",

"cmZsb3cuVGVuc29yQ29ubmVjdGlvbhJCCgxmZWVkX2RldmljZXMYBiADKAsy",

"LC50ZW5zb3JmbG93LkNhbGxhYmxlT3B0aW9ucy5GZWVkRGV2aWNlc0VudHJ5",

"EkQKDWZldGNoX2RldmljZXMYByADKAsyLS50ZW5zb3JmbG93LkNhbGxhYmxl",

"T3B0aW9ucy5GZXRjaERldmljZXNFbnRyeRIXCg9mZXRjaF9za2lwX3N5bmMY",

"CCABKAgaMgoQRmVlZERldmljZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFs",

"dWUYAiABKAk6AjgBGjMKEUZldGNoRGV2aWNlc0VudHJ5EgsKA2tleRgBIAEo",

"CRINCgV2YWx1ZRgCIAEoCToCOAFCawoYb3JnLnRlbnNvcmZsb3cuZnJhbWV3",

"b3JrQgxDb25maWdQcm90b3NQAVo8Z2l0aHViLmNvbS90ZW5zb3JmbG93L3Rl",

"bnNvcmZsb3cvdGVuc29yZmxvdy9nby9jb3JlL3Byb3RvYnVm+AEBYgZwcm90",

"bzM="));

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" }, 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", "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", "DisableOutputPartitionGraphs", "XlaFusionAutotunerThresh" }, null, null, 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" }, 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;

}

}

}

}

#region Nested types

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

[global::System.Diagnostics.DebuggerNonUserCodeAttribute]

public static partial class Types {

/// <summary>

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

/// devices.

/// </summary>

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

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