Class ConfigProto.Builder

java.lang.Object
com.google.protobuf.AbstractMessageLite.Builder
com.google.protobuf.AbstractMessage.Builder<ConfigProto.Builder>
com.google.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>
org.tensorflow.proto.ConfigProto.Builder
All Implemented Interfaces:
Message.Builder, MessageLite.Builder, MessageLiteOrBuilder, MessageOrBuilder, Cloneable, ConfigProtoOrBuilder
Enclosing class:
ConfigProto
public static final class ConfigProto.Builder extends GeneratedMessageV3.Builder<ConfigProto.Builder> implements ConfigProtoOrBuilder
Session configuration parameters.
The system picks appropriate values for fields that are not set.
Protobuf type tensorflow.ConfigProto

  • Method Details

    • getDescriptor

      public static final Descriptors.Descriptor getDescriptor()

    • internalGetMapField

      protected MapField internalGetMapField(int number)
      Overrides:
      internalGetMapField in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • internalGetMutableMapField

      protected MapField internalGetMutableMapField(int number)
      Overrides:
      internalGetMutableMapField in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • internalGetFieldAccessorTable

      protected GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()
      Specified by:
      internalGetFieldAccessorTable in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • clear

      public ConfigProto.Builder clear()
      Specified by:
      clear in interface Message.Builder
      Specified by:
      clear in interface MessageLite.Builder
      Overrides:
      clear in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • getDescriptorForType

      public Descriptors.Descriptor getDescriptorForType()
      Specified by:
      getDescriptorForType in interface Message.Builder
      Specified by:
      getDescriptorForType in interface MessageOrBuilder
      Overrides:
      getDescriptorForType in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • getDefaultInstanceForType

      public ConfigProto getDefaultInstanceForType()
      Specified by:
      getDefaultInstanceForType in interface MessageLiteOrBuilder
      Specified by:
      getDefaultInstanceForType in interface MessageOrBuilder

    • build

      public ConfigProto build()
      Specified by:
      build in interface Message.Builder
      Specified by:
      build in interface MessageLite.Builder

    • buildPartial

      public ConfigProto buildPartial()
      Specified by:
      buildPartial in interface Message.Builder
      Specified by:
      buildPartial in interface MessageLite.Builder

    • clone

      public ConfigProto.Builder clone()
      Specified by:
      clone in interface Message.Builder
      Specified by:
      clone in interface MessageLite.Builder
      Overrides:
      clone in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • setField

      public ConfigProto.Builder setField(Descriptors.FieldDescriptor field, Object value)
      Specified by:
      setField in interface Message.Builder
      Overrides:
      setField in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • clearField

      public ConfigProto.Builder clearField(Descriptors.FieldDescriptor field)
      Specified by:
      clearField in interface Message.Builder
      Overrides:
      clearField in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • clearOneof

      public ConfigProto.Builder clearOneof(Descriptors.OneofDescriptor oneof)
      Specified by:
      clearOneof in interface Message.Builder
      Overrides:
      clearOneof in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • setRepeatedField

      public ConfigProto.Builder setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value)
      Specified by:
      setRepeatedField in interface Message.Builder
      Overrides:
      setRepeatedField in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • addRepeatedField

      public ConfigProto.Builder addRepeatedField(Descriptors.FieldDescriptor field, Object value)
      Specified by:
      addRepeatedField in interface Message.Builder
      Overrides:
      addRepeatedField in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • mergeFrom

      public ConfigProto.Builder mergeFrom(Message other)
      Specified by:
      mergeFrom in interface Message.Builder
      Overrides:
      mergeFrom in class AbstractMessage.Builder<ConfigProto.Builder>

    • mergeFrom

      public ConfigProto.Builder mergeFrom(ConfigProto other)

    • isInitialized

      public final boolean isInitialized()
      Specified by:
      isInitialized in interface MessageLiteOrBuilder
      Overrides:
      isInitialized in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • mergeFrom

      public ConfigProto.Builder mergeFrom(CodedInputStream input, ExtensionRegistryLite extensionRegistry) throws IOException
      Specified by:
      mergeFrom in interface Message.Builder
      Specified by:
      mergeFrom in interface MessageLite.Builder
      Overrides:
      mergeFrom in class AbstractMessage.Builder<ConfigProto.Builder>
      Throws:
      IOException

    • getDeviceCountCount

      public int getDeviceCountCount()
      Description copied from interface: ConfigProtoOrBuilder
      Map from device type name (e.g., "CPU" or "GPU" ) to maximum
number of devices of that type to use.  If a particular device
type is not found in the map, the system picks an appropriate
number.
      map<string, int32> device_count = 1;
      Specified by:
      getDeviceCountCount in interface ConfigProtoOrBuilder

    • containsDeviceCount

      public boolean containsDeviceCount(String key)
      Map from device type name (e.g., "CPU" or "GPU" ) to maximum
number of devices of that type to use.  If a particular device
type is not found in the map, the system picks an appropriate
number.
      map<string, int32> device_count = 1;
      Specified by:
      containsDeviceCount in interface ConfigProtoOrBuilder

    • getDeviceCount

      @Deprecated public Map<String,Integer> getDeviceCount()
      Deprecated.
      Use getDeviceCountMap() instead.
      Specified by:
      getDeviceCount in interface ConfigProtoOrBuilder

    • getDeviceCountMap

      public Map<String,Integer> getDeviceCountMap()
      Map from device type name (e.g., "CPU" or "GPU" ) to maximum
number of devices of that type to use.  If a particular device
type is not found in the map, the system picks an appropriate
number.
      map<string, int32> device_count = 1;
      Specified by:
      getDeviceCountMap in interface ConfigProtoOrBuilder

    • getDeviceCountOrDefault

      public int getDeviceCountOrDefault(String key, int defaultValue)
      Map from device type name (e.g., "CPU" or "GPU" ) to maximum
number of devices of that type to use.  If a particular device
type is not found in the map, the system picks an appropriate
number.
      map<string, int32> device_count = 1;
      Specified by:
      getDeviceCountOrDefault in interface ConfigProtoOrBuilder

    • getDeviceCountOrThrow

      public int getDeviceCountOrThrow(String key)
      Map from device type name (e.g., "CPU" or "GPU" ) to maximum
number of devices of that type to use.  If a particular device
type is not found in the map, the system picks an appropriate
number.
      map<string, int32> device_count = 1;
      Specified by:
      getDeviceCountOrThrow in interface ConfigProtoOrBuilder

    • clearDeviceCount

      public ConfigProto.Builder clearDeviceCount()

    • removeDeviceCount

      public ConfigProto.Builder removeDeviceCount(String key)
      Map from device type name (e.g., "CPU" or "GPU" ) to maximum
number of devices of that type to use.  If a particular device
type is not found in the map, the system picks an appropriate
number.
      map<string, int32> device_count = 1;

    • getMutableDeviceCount

      @Deprecated public Map<String,Integer> getMutableDeviceCount()
      Deprecated.
      Use alternate mutation accessors instead.

    • putDeviceCount

      public ConfigProto.Builder putDeviceCount(String key, int value)
      Map from device type name (e.g., "CPU" or "GPU" ) to maximum
number of devices of that type to use.  If a particular device
type is not found in the map, the system picks an appropriate
number.
      map<string, int32> device_count = 1;

    • putAllDeviceCount

      public ConfigProto.Builder putAllDeviceCount(Map<String,Integer> values)
      Map from device type name (e.g., "CPU" or "GPU" ) to maximum
number of devices of that type to use.  If a particular device
type is not found in the map, the system picks an appropriate
number.
      map<string, int32> device_count = 1;

    • getIntraOpParallelismThreads

      public int getIntraOpParallelismThreads()
      The execution of an individual op (for some op types) can be
parallelized on a pool of intra_op_parallelism_threads.
0 means the system picks an appropriate number.
If you create an ordinary session, e.g., from Python or C++,
then there is exactly one intra op thread pool per process.
The first session created determines the number of threads in this pool.
All subsequent sessions reuse/share this one global pool.
There are notable exceptions to the default behavior described above:
1. There is an environment variable  for overriding this thread pool,
   named TF_OVERRIDE_GLOBAL_THREADPOOL.
2. When connecting to a server, such as a remote `tf.train.Server`
   instance, then this option will be ignored altogether.
      int32 intra_op_parallelism_threads = 2;
      Specified by:
      getIntraOpParallelismThreads in interface ConfigProtoOrBuilder
      Returns:
      The intraOpParallelismThreads.

    • setIntraOpParallelismThreads

      public ConfigProto.Builder setIntraOpParallelismThreads(int value)
      The execution of an individual op (for some op types) can be
parallelized on a pool of intra_op_parallelism_threads.
0 means the system picks an appropriate number.
If you create an ordinary session, e.g., from Python or C++,
then there is exactly one intra op thread pool per process.
The first session created determines the number of threads in this pool.
All subsequent sessions reuse/share this one global pool.
There are notable exceptions to the default behavior described above:
1. There is an environment variable  for overriding this thread pool,
   named TF_OVERRIDE_GLOBAL_THREADPOOL.
2. When connecting to a server, such as a remote `tf.train.Server`
   instance, then this option will be ignored altogether.
      int32 intra_op_parallelism_threads = 2;
      Parameters:
      value - The intraOpParallelismThreads to set.
      Returns:
      This builder for chaining.

    • clearIntraOpParallelismThreads

      public ConfigProto.Builder clearIntraOpParallelismThreads()
      The execution of an individual op (for some op types) can be
parallelized on a pool of intra_op_parallelism_threads.
0 means the system picks an appropriate number.
If you create an ordinary session, e.g., from Python or C++,
then there is exactly one intra op thread pool per process.
The first session created determines the number of threads in this pool.
All subsequent sessions reuse/share this one global pool.
There are notable exceptions to the default behavior described above:
1. There is an environment variable  for overriding this thread pool,
   named TF_OVERRIDE_GLOBAL_THREADPOOL.
2. When connecting to a server, such as a remote `tf.train.Server`
   instance, then this option will be ignored altogether.
      int32 intra_op_parallelism_threads = 2;
      Returns:
      This builder for chaining.

    • getInterOpParallelismThreads

      public int getInterOpParallelismThreads()
      Nodes that perform blocking operations are enqueued on a pool of
inter_op_parallelism_threads available in each process.
0 means the system picks an appropriate number.
Negative means all operations are performed in caller's thread.
Note that the first Session created in the process sets the
number of threads for all future sessions unless use_per_session_threads is
true or session_inter_op_thread_pool is configured.
      int32 inter_op_parallelism_threads = 5;
      Specified by:
      getInterOpParallelismThreads in interface ConfigProtoOrBuilder
      Returns:
      The interOpParallelismThreads.

    • setInterOpParallelismThreads

      public ConfigProto.Builder setInterOpParallelismThreads(int value)
      Nodes that perform blocking operations are enqueued on a pool of
inter_op_parallelism_threads available in each process.
0 means the system picks an appropriate number.
Negative means all operations are performed in caller's thread.
Note that the first Session created in the process sets the
number of threads for all future sessions unless use_per_session_threads is
true or session_inter_op_thread_pool is configured.
      int32 inter_op_parallelism_threads = 5;
      Parameters:
      value - The interOpParallelismThreads to set.
      Returns:
      This builder for chaining.

    • clearInterOpParallelismThreads

      public ConfigProto.Builder clearInterOpParallelismThreads()
      Nodes that perform blocking operations are enqueued on a pool of
inter_op_parallelism_threads available in each process.
0 means the system picks an appropriate number.
Negative means all operations are performed in caller's thread.
Note that the first Session created in the process sets the
number of threads for all future sessions unless use_per_session_threads is
true or session_inter_op_thread_pool is configured.
      int32 inter_op_parallelism_threads = 5;
      Returns:
      This builder for chaining.

    • getUsePerSessionThreads

      public boolean getUsePerSessionThreads()
      If true, use a new set of threads for this session rather than the global
pool of threads. Only supported by direct sessions.
If false, use the global threads created by the first session, or the
per-session thread pools configured by session_inter_op_thread_pool.
This option is deprecated. The same effect can be achieved by setting
session_inter_op_thread_pool to have one element, whose num_threads equals
inter_op_parallelism_threads.
      bool use_per_session_threads = 9;
      Specified by:
      getUsePerSessionThreads in interface ConfigProtoOrBuilder
      Returns:
      The usePerSessionThreads.

    • setUsePerSessionThreads

      public ConfigProto.Builder setUsePerSessionThreads(boolean value)
      If true, use a new set of threads for this session rather than the global
pool of threads. Only supported by direct sessions.
If false, use the global threads created by the first session, or the
per-session thread pools configured by session_inter_op_thread_pool.
This option is deprecated. The same effect can be achieved by setting
session_inter_op_thread_pool to have one element, whose num_threads equals
inter_op_parallelism_threads.
      bool use_per_session_threads = 9;
      Parameters:
      value - The usePerSessionThreads to set.
      Returns:
      This builder for chaining.

    • clearUsePerSessionThreads

      public ConfigProto.Builder clearUsePerSessionThreads()
      If true, use a new set of threads for this session rather than the global
pool of threads. Only supported by direct sessions.
If false, use the global threads created by the first session, or the
per-session thread pools configured by session_inter_op_thread_pool.
This option is deprecated. The same effect can be achieved by setting
session_inter_op_thread_pool to have one element, whose num_threads equals
inter_op_parallelism_threads.
      bool use_per_session_threads = 9;
      Returns:
      This builder for chaining.

    • getSessionInterOpThreadPoolList

      public List<ThreadPoolOptionProto> getSessionInterOpThreadPoolList()
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;
      Specified by:
      getSessionInterOpThreadPoolList in interface ConfigProtoOrBuilder

    • getSessionInterOpThreadPoolCount

      public int getSessionInterOpThreadPoolCount()
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;
      Specified by:
      getSessionInterOpThreadPoolCount in interface ConfigProtoOrBuilder

    • getSessionInterOpThreadPool

      public ThreadPoolOptionProto getSessionInterOpThreadPool(int index)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;
      Specified by:
      getSessionInterOpThreadPool in interface ConfigProtoOrBuilder

    • setSessionInterOpThreadPool

      public ConfigProto.Builder setSessionInterOpThreadPool(int index, ThreadPoolOptionProto value)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • setSessionInterOpThreadPool

      public ConfigProto.Builder setSessionInterOpThreadPool(int index, ThreadPoolOptionProto.Builder builderForValue)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • addSessionInterOpThreadPool

      public ConfigProto.Builder addSessionInterOpThreadPool(ThreadPoolOptionProto value)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • addSessionInterOpThreadPool

      public ConfigProto.Builder addSessionInterOpThreadPool(int index, ThreadPoolOptionProto value)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • addSessionInterOpThreadPool

      public ConfigProto.Builder addSessionInterOpThreadPool(ThreadPoolOptionProto.Builder builderForValue)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • addSessionInterOpThreadPool

      public ConfigProto.Builder addSessionInterOpThreadPool(int index, ThreadPoolOptionProto.Builder builderForValue)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • addAllSessionInterOpThreadPool

      public ConfigProto.Builder addAllSessionInterOpThreadPool(Iterable<? extends ThreadPoolOptionProto> values)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • clearSessionInterOpThreadPool

      public ConfigProto.Builder clearSessionInterOpThreadPool()
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • removeSessionInterOpThreadPool

      public ConfigProto.Builder removeSessionInterOpThreadPool(int index)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • getSessionInterOpThreadPoolBuilder

      public ThreadPoolOptionProto.Builder getSessionInterOpThreadPoolBuilder(int index)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • getSessionInterOpThreadPoolOrBuilder

      public ThreadPoolOptionProtoOrBuilder getSessionInterOpThreadPoolOrBuilder(int index)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;
      Specified by:
      getSessionInterOpThreadPoolOrBuilder in interface ConfigProtoOrBuilder

    • getSessionInterOpThreadPoolOrBuilderList

      public List<? extends ThreadPoolOptionProtoOrBuilder> getSessionInterOpThreadPoolOrBuilderList()
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;
      Specified by:
      getSessionInterOpThreadPoolOrBuilderList in interface ConfigProtoOrBuilder

    • addSessionInterOpThreadPoolBuilder

      public ThreadPoolOptionProto.Builder addSessionInterOpThreadPoolBuilder()
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • addSessionInterOpThreadPoolBuilder

      public ThreadPoolOptionProto.Builder addSessionInterOpThreadPoolBuilder(int index)
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • getSessionInterOpThreadPoolBuilderList

      public List<ThreadPoolOptionProto.Builder> getSessionInterOpThreadPoolBuilderList()
      This option is experimental - it may be replaced with a different mechanism
in the future.
Configures session thread pools. If this is configured, then RunOptions for
a Run call can select the thread pool to use.
The intended use is for when some session invocations need to run in a
background pool limited to a small number of threads:
- For example, a session may be configured to have one large pool (for
regular compute) and one small pool (for periodic, low priority work);
using the small pool is currently the mechanism for limiting the inter-op
parallelism of the low priority work.  Note that it does not limit the
parallelism of work spawned by a single op kernel implementation.
- Using this setting is normally not needed in training, but may help some
serving use cases.
- It is also generally recommended to set the global_name field of this
proto, to avoid creating multiple large pools. It is typically better to
run the non-low-priority work, even across sessions, in a single large
pool.
      repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

    • getPlacementPeriod

      public int getPlacementPeriod()
      Assignment of Nodes to Devices is recomputed every placement_period
steps until the system warms up (at which point the recomputation
typically slows down automatically).
      int32 placement_period = 3;
      Specified by:
      getPlacementPeriod in interface ConfigProtoOrBuilder
      Returns:
      The placementPeriod.

    • setPlacementPeriod

      public ConfigProto.Builder setPlacementPeriod(int value)
      Assignment of Nodes to Devices is recomputed every placement_period
steps until the system warms up (at which point the recomputation
typically slows down automatically).
      int32 placement_period = 3;
      Parameters:
      value - The placementPeriod to set.
      Returns:
      This builder for chaining.

    • clearPlacementPeriod

      public ConfigProto.Builder clearPlacementPeriod()
      Assignment of Nodes to Devices is recomputed every placement_period
steps until the system warms up (at which point the recomputation
typically slows down automatically).
      int32 placement_period = 3;
      Returns:
      This builder for chaining.

    • getDeviceFiltersList

      public ProtocolStringList getDeviceFiltersList()
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Specified by:
      getDeviceFiltersList in interface ConfigProtoOrBuilder
      Returns:
      A list containing the deviceFilters.

    • getDeviceFiltersCount

      public int getDeviceFiltersCount()
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Specified by:
      getDeviceFiltersCount in interface ConfigProtoOrBuilder
      Returns:
      The count of deviceFilters.

    • getDeviceFilters

      public String getDeviceFilters(int index)
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Specified by:
      getDeviceFilters in interface ConfigProtoOrBuilder
      Parameters:
      index - The index of the element to return.
      Returns:
      The deviceFilters at the given index.

    • getDeviceFiltersBytes

      public ByteString getDeviceFiltersBytes(int index)
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Specified by:
      getDeviceFiltersBytes in interface ConfigProtoOrBuilder
      Parameters:
      index - The index of the value to return.
      Returns:
      The bytes of the deviceFilters at the given index.

    • setDeviceFilters

      public ConfigProto.Builder setDeviceFilters(int index, String value)
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Parameters:
      index - The index to set the value at.
      value - The deviceFilters to set.
      Returns:
      This builder for chaining.

    • addDeviceFilters

      public ConfigProto.Builder addDeviceFilters(String value)
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Parameters:
      value - The deviceFilters to add.
      Returns:
      This builder for chaining.

    • addAllDeviceFilters

      public ConfigProto.Builder addAllDeviceFilters(Iterable<String> values)
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Parameters:
      values - The deviceFilters to add.
      Returns:
      This builder for chaining.

    • clearDeviceFilters

      public ConfigProto.Builder clearDeviceFilters()
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Returns:
      This builder for chaining.

    • addDeviceFiltersBytes

      public ConfigProto.Builder addDeviceFiltersBytes(ByteString value)
      When any filters are present sessions will ignore all devices which do not
match the filters. Each filter can be partially specified, e.g. "/job:ps"
"/job:worker/replica:3", etc.
      repeated string device_filters = 4;
      Parameters:
      value - The bytes of the deviceFilters to add.
      Returns:
      This builder for chaining.

    • hasGpuOptions

      public boolean hasGpuOptions()
      Options that apply to all GPUs.
      .tensorflow.GPUOptions gpu_options = 6;
      Specified by:
      hasGpuOptions in interface ConfigProtoOrBuilder
      Returns:
      Whether the gpuOptions field is set.

    • getGpuOptions

      public GPUOptions getGpuOptions()
      Options that apply to all GPUs.
      .tensorflow.GPUOptions gpu_options = 6;
      Specified by:
      getGpuOptions in interface ConfigProtoOrBuilder
      Returns:
      The gpuOptions.

    • setGpuOptions

      public ConfigProto.Builder setGpuOptions(GPUOptions value)
      Options that apply to all GPUs.
      .tensorflow.GPUOptions gpu_options = 6;

    • setGpuOptions

      public ConfigProto.Builder setGpuOptions(GPUOptions.Builder builderForValue)
      Options that apply to all GPUs.
      .tensorflow.GPUOptions gpu_options = 6;

    • mergeGpuOptions

      public ConfigProto.Builder mergeGpuOptions(GPUOptions value)
      Options that apply to all GPUs.
      .tensorflow.GPUOptions gpu_options = 6;

    • clearGpuOptions

      public ConfigProto.Builder clearGpuOptions()
      Options that apply to all GPUs.
      .tensorflow.GPUOptions gpu_options = 6;

    • getGpuOptionsBuilder

      public GPUOptions.Builder getGpuOptionsBuilder()
      Options that apply to all GPUs.
      .tensorflow.GPUOptions gpu_options = 6;

    • getGpuOptionsOrBuilder

      public GPUOptionsOrBuilder getGpuOptionsOrBuilder()
      Options that apply to all GPUs.
      .tensorflow.GPUOptions gpu_options = 6;
      Specified by:
      getGpuOptionsOrBuilder in interface ConfigProtoOrBuilder

    • hasPluggableDeviceOptions

      public boolean hasPluggableDeviceOptions()
      Options that apply to pluggable devices.
      .tensorflow.GPUOptions pluggable_device_options = 18;
      Specified by:
      hasPluggableDeviceOptions in interface ConfigProtoOrBuilder
      Returns:
      Whether the pluggableDeviceOptions field is set.

    • getPluggableDeviceOptions

      public GPUOptions getPluggableDeviceOptions()
      Options that apply to pluggable devices.
      .tensorflow.GPUOptions pluggable_device_options = 18;
      Specified by:
      getPluggableDeviceOptions in interface ConfigProtoOrBuilder
      Returns:
      The pluggableDeviceOptions.

    • setPluggableDeviceOptions

      public ConfigProto.Builder setPluggableDeviceOptions(GPUOptions value)
      Options that apply to pluggable devices.
      .tensorflow.GPUOptions pluggable_device_options = 18;

    • setPluggableDeviceOptions

      public ConfigProto.Builder setPluggableDeviceOptions(GPUOptions.Builder builderForValue)
      Options that apply to pluggable devices.
      .tensorflow.GPUOptions pluggable_device_options = 18;

    • mergePluggableDeviceOptions

      public ConfigProto.Builder mergePluggableDeviceOptions(GPUOptions value)
      Options that apply to pluggable devices.
      .tensorflow.GPUOptions pluggable_device_options = 18;

    • clearPluggableDeviceOptions

      public ConfigProto.Builder clearPluggableDeviceOptions()
      Options that apply to pluggable devices.
      .tensorflow.GPUOptions pluggable_device_options = 18;

    • getPluggableDeviceOptionsBuilder

      public GPUOptions.Builder getPluggableDeviceOptionsBuilder()
      Options that apply to pluggable devices.
      .tensorflow.GPUOptions pluggable_device_options = 18;

    • getPluggableDeviceOptionsOrBuilder

      public GPUOptionsOrBuilder getPluggableDeviceOptionsOrBuilder()
      Options that apply to pluggable devices.
      .tensorflow.GPUOptions pluggable_device_options = 18;
      Specified by:
      getPluggableDeviceOptionsOrBuilder in interface ConfigProtoOrBuilder

    • getAllowSoftPlacement

      public boolean getAllowSoftPlacement()
      Whether soft placement is allowed. If allow_soft_placement is true,
an op will be placed on CPU if
  1. there's no GPU implementation for the OP
or
  2. no GPU devices are known or registered
or
  3. need to co-locate with reftype input(s) which are from CPU.
      bool allow_soft_placement = 7;
      Specified by:
      getAllowSoftPlacement in interface ConfigProtoOrBuilder
      Returns:
      The allowSoftPlacement.

    • setAllowSoftPlacement

      public ConfigProto.Builder setAllowSoftPlacement(boolean value)
      Whether soft placement is allowed. If allow_soft_placement is true,
an op will be placed on CPU if
  1. there's no GPU implementation for the OP
or
  2. no GPU devices are known or registered
or
  3. need to co-locate with reftype input(s) which are from CPU.
      bool allow_soft_placement = 7;
      Parameters:
      value - The allowSoftPlacement to set.
      Returns:
      This builder for chaining.

    • clearAllowSoftPlacement

      public ConfigProto.Builder clearAllowSoftPlacement()
      Whether soft placement is allowed. If allow_soft_placement is true,
an op will be placed on CPU if
  1. there's no GPU implementation for the OP
or
  2. no GPU devices are known or registered
or
  3. need to co-locate with reftype input(s) which are from CPU.
      bool allow_soft_placement = 7;
      Returns:
      This builder for chaining.

    • getLogDevicePlacement

      public boolean getLogDevicePlacement()
      Whether device placements should be logged.
      bool log_device_placement = 8;
      Specified by:
      getLogDevicePlacement in interface ConfigProtoOrBuilder
      Returns:
      The logDevicePlacement.

    • setLogDevicePlacement

      public ConfigProto.Builder setLogDevicePlacement(boolean value)
      Whether device placements should be logged.
      bool log_device_placement = 8;
      Parameters:
      value - The logDevicePlacement to set.
      Returns:
      This builder for chaining.

    • clearLogDevicePlacement

      public ConfigProto.Builder clearLogDevicePlacement()
      Whether device placements should be logged.
      bool log_device_placement = 8;
      Returns:
      This builder for chaining.

    • hasGraphOptions

      public boolean hasGraphOptions()
      Options that apply to all graphs.
      .tensorflow.GraphOptions graph_options = 10;
      Specified by:
      hasGraphOptions in interface ConfigProtoOrBuilder
      Returns:
      Whether the graphOptions field is set.

    • getGraphOptions

      public GraphOptions getGraphOptions()
      Options that apply to all graphs.
      .tensorflow.GraphOptions graph_options = 10;
      Specified by:
      getGraphOptions in interface ConfigProtoOrBuilder
      Returns:
      The graphOptions.

    • setGraphOptions

      public ConfigProto.Builder setGraphOptions(GraphOptions value)
      Options that apply to all graphs.
      .tensorflow.GraphOptions graph_options = 10;

    • setGraphOptions

      public ConfigProto.Builder setGraphOptions(GraphOptions.Builder builderForValue)
      Options that apply to all graphs.
      .tensorflow.GraphOptions graph_options = 10;

    • mergeGraphOptions

      public ConfigProto.Builder mergeGraphOptions(GraphOptions value)
      Options that apply to all graphs.
      .tensorflow.GraphOptions graph_options = 10;

    • clearGraphOptions

      public ConfigProto.Builder clearGraphOptions()
      Options that apply to all graphs.
      .tensorflow.GraphOptions graph_options = 10;

    • getGraphOptionsBuilder

      public GraphOptions.Builder getGraphOptionsBuilder()
      Options that apply to all graphs.
      .tensorflow.GraphOptions graph_options = 10;

    • getGraphOptionsOrBuilder

      public GraphOptionsOrBuilder getGraphOptionsOrBuilder()
      Options that apply to all graphs.
      .tensorflow.GraphOptions graph_options = 10;
      Specified by:
      getGraphOptionsOrBuilder in interface ConfigProtoOrBuilder

    • getOperationTimeoutInMs

      public long getOperationTimeoutInMs()
      Global timeout for all blocking operations in this session.  If non-zero,
and not overridden on a per-operation basis, this value will be used as the
deadline for all blocking operations.
      int64 operation_timeout_in_ms = 11;
      Specified by:
      getOperationTimeoutInMs in interface ConfigProtoOrBuilder
      Returns:
      The operationTimeoutInMs.

    • setOperationTimeoutInMs

      public ConfigProto.Builder setOperationTimeoutInMs(long value)
      Global timeout for all blocking operations in this session.  If non-zero,
and not overridden on a per-operation basis, this value will be used as the
deadline for all blocking operations.
      int64 operation_timeout_in_ms = 11;
      Parameters:
      value - The operationTimeoutInMs to set.
      Returns:
      This builder for chaining.

    • clearOperationTimeoutInMs

      public ConfigProto.Builder clearOperationTimeoutInMs()
      Global timeout for all blocking operations in this session.  If non-zero,
and not overridden on a per-operation basis, this value will be used as the
deadline for all blocking operations.
      int64 operation_timeout_in_ms = 11;
      Returns:
      This builder for chaining.

    • hasRpcOptions

      public boolean hasRpcOptions()
      Options that apply when this session uses the distributed runtime.
      .tensorflow.RPCOptions rpc_options = 13;
      Specified by:
      hasRpcOptions in interface ConfigProtoOrBuilder
      Returns:
      Whether the rpcOptions field is set.

    • getRpcOptions

      public RpcOptions.RPCOptions getRpcOptions()
      Options that apply when this session uses the distributed runtime.
      .tensorflow.RPCOptions rpc_options = 13;
      Specified by:
      getRpcOptions in interface ConfigProtoOrBuilder
      Returns:
      The rpcOptions.

    • setRpcOptions

      public ConfigProto.Builder setRpcOptions(RpcOptions.RPCOptions value)
      Options that apply when this session uses the distributed runtime.
      .tensorflow.RPCOptions rpc_options = 13;

    • setRpcOptions

      public ConfigProto.Builder setRpcOptions(RpcOptions.RPCOptions.Builder builderForValue)
      Options that apply when this session uses the distributed runtime.
      .tensorflow.RPCOptions rpc_options = 13;

    • mergeRpcOptions

      public ConfigProto.Builder mergeRpcOptions(RpcOptions.RPCOptions value)
      Options that apply when this session uses the distributed runtime.
      .tensorflow.RPCOptions rpc_options = 13;

    • clearRpcOptions

      public ConfigProto.Builder clearRpcOptions()
      Options that apply when this session uses the distributed runtime.
      .tensorflow.RPCOptions rpc_options = 13;

    • getRpcOptionsBuilder

      public RpcOptions.RPCOptions.Builder getRpcOptionsBuilder()
      Options that apply when this session uses the distributed runtime.
      .tensorflow.RPCOptions rpc_options = 13;

    • getRpcOptionsOrBuilder

      public RpcOptions.RPCOptionsOrBuilder getRpcOptionsOrBuilder()
      Options that apply when this session uses the distributed runtime.
      .tensorflow.RPCOptions rpc_options = 13;
      Specified by:
      getRpcOptionsOrBuilder in interface ConfigProtoOrBuilder

    • hasClusterDef

      public boolean hasClusterDef()
      Optional list of all workers to use in this session.
      .tensorflow.ClusterDef cluster_def = 14;
      Specified by:
      hasClusterDef in interface ConfigProtoOrBuilder
      Returns:
      Whether the clusterDef field is set.

    • getClusterDef

      public ClusterDef getClusterDef()
      Optional list of all workers to use in this session.
      .tensorflow.ClusterDef cluster_def = 14;
      Specified by:
      getClusterDef in interface ConfigProtoOrBuilder
      Returns:
      The clusterDef.

    • setClusterDef

      public ConfigProto.Builder setClusterDef(ClusterDef value)
      Optional list of all workers to use in this session.
      .tensorflow.ClusterDef cluster_def = 14;

    • setClusterDef

      public ConfigProto.Builder setClusterDef(ClusterDef.Builder builderForValue)
      Optional list of all workers to use in this session.
      .tensorflow.ClusterDef cluster_def = 14;

    • mergeClusterDef

      public ConfigProto.Builder mergeClusterDef(ClusterDef value)
      Optional list of all workers to use in this session.
      .tensorflow.ClusterDef cluster_def = 14;

    • clearClusterDef

      public ConfigProto.Builder clearClusterDef()
      Optional list of all workers to use in this session.
      .tensorflow.ClusterDef cluster_def = 14;

    • getClusterDefBuilder

      public ClusterDef.Builder getClusterDefBuilder()
      Optional list of all workers to use in this session.
      .tensorflow.ClusterDef cluster_def = 14;

    • getClusterDefOrBuilder

      public ClusterDefOrBuilder getClusterDefOrBuilder()
      Optional list of all workers to use in this session.
      .tensorflow.ClusterDef cluster_def = 14;
      Specified by:
      getClusterDefOrBuilder in interface ConfigProtoOrBuilder

    • getIsolateSessionState

      public boolean getIsolateSessionState()
      If true, any resources such as Variables used in the session will not be
shared with other sessions. However, when clusterspec propagation is
enabled, this field is ignored and sessions are always isolated.
      bool isolate_session_state = 15;
      Specified by:
      getIsolateSessionState in interface ConfigProtoOrBuilder
      Returns:
      The isolateSessionState.

    • setIsolateSessionState

      public ConfigProto.Builder setIsolateSessionState(boolean value)
      If true, any resources such as Variables used in the session will not be
shared with other sessions. However, when clusterspec propagation is
enabled, this field is ignored and sessions are always isolated.
      bool isolate_session_state = 15;
      Parameters:
      value - The isolateSessionState to set.
      Returns:
      This builder for chaining.

    • clearIsolateSessionState

      public ConfigProto.Builder clearIsolateSessionState()
      If true, any resources such as Variables used in the session will not be
shared with other sessions. However, when clusterspec propagation is
enabled, this field is ignored and sessions are always isolated.
      bool isolate_session_state = 15;
      Returns:
      This builder for chaining.

    • getShareClusterDevicesInSession

      public boolean getShareClusterDevicesInSession()
      When true, WorkerSessions are created with device attributes from the
full cluster.
This is helpful when a worker wants to partition a graph
(for example during a PartitionedCallOp).
      bool share_cluster_devices_in_session = 17;
      Specified by:
      getShareClusterDevicesInSession in interface ConfigProtoOrBuilder
      Returns:
      The shareClusterDevicesInSession.

    • setShareClusterDevicesInSession

      public ConfigProto.Builder setShareClusterDevicesInSession(boolean value)
      When true, WorkerSessions are created with device attributes from the
full cluster.
This is helpful when a worker wants to partition a graph
(for example during a PartitionedCallOp).
      bool share_cluster_devices_in_session = 17;
      Parameters:
      value - The shareClusterDevicesInSession to set.
      Returns:
      This builder for chaining.

    • clearShareClusterDevicesInSession

      public ConfigProto.Builder clearShareClusterDevicesInSession()
      When true, WorkerSessions are created with device attributes from the
full cluster.
This is helpful when a worker wants to partition a graph
(for example during a PartitionedCallOp).
      bool share_cluster_devices_in_session = 17;
      Returns:
      This builder for chaining.

    • hasExperimental

      public boolean hasExperimental()
      .tensorflow.ConfigProto.Experimental experimental = 16;
      Specified by:
      hasExperimental in interface ConfigProtoOrBuilder
      Returns:
      Whether the experimental field is set.

    • getExperimental

      public ConfigProto.Experimental getExperimental()
      .tensorflow.ConfigProto.Experimental experimental = 16;
      Specified by:
      getExperimental in interface ConfigProtoOrBuilder
      Returns:
      The experimental.

    • setExperimental

      public ConfigProto.Builder setExperimental(ConfigProto.Experimental value)
      .tensorflow.ConfigProto.Experimental experimental = 16;

    • setExperimental

      public ConfigProto.Builder setExperimental(ConfigProto.Experimental.Builder builderForValue)
      .tensorflow.ConfigProto.Experimental experimental = 16;

    • mergeExperimental

      public ConfigProto.Builder mergeExperimental(ConfigProto.Experimental value)
      .tensorflow.ConfigProto.Experimental experimental = 16;

    • clearExperimental

      public ConfigProto.Builder clearExperimental()
      .tensorflow.ConfigProto.Experimental experimental = 16;

    • getExperimentalBuilder

      public ConfigProto.Experimental.Builder getExperimentalBuilder()
      .tensorflow.ConfigProto.Experimental experimental = 16;

    • getExperimentalOrBuilder

      public ConfigProto.ExperimentalOrBuilder getExperimentalOrBuilder()
      .tensorflow.ConfigProto.Experimental experimental = 16;
      Specified by:
      getExperimentalOrBuilder in interface ConfigProtoOrBuilder

    • setUnknownFields

      public final ConfigProto.Builder setUnknownFields(UnknownFieldSet unknownFields)
      Specified by:
      setUnknownFields in interface Message.Builder
      Overrides:
      setUnknownFields in class GeneratedMessageV3.Builder<ConfigProto.Builder>

    • mergeUnknownFields

      public final ConfigProto.Builder mergeUnknownFields(UnknownFieldSet unknownFields)
      Specified by:
      mergeUnknownFields in interface Message.Builder
      Overrides:
      mergeUnknownFields in class GeneratedMessageV3.Builder<ConfigProto.Builder>