Options for TAO Components

Table of Contents

• Introduction
• Choosing the Right Approach
• TAO's ORB Configuration Options
  • Environment Variables
  • Command-line Options
    1. Controlling Service Configurator Behavior
    2. Controlling Debugging Information
    3. Optimizing Request Processing
    4. Connection Management and Protocol Selection
    5. Miscellaneous Options
  • Service Configuration File
    1. Simple and Advanced Resource Factories
       1. TAO_Default_Resource_Factory
       2. TAO_Advanced_Resource_Factory
    2. Server_Strategy_Factory
    3. Client_Strategy_Factory

Introduction

• Settings, which are options that can be assigned values differing from their default settings. Examples include setting the size of a Portable Object Adapter (POA)'s active object map or configuring the ORB to print debugging information as it processes requests. A few of these are run-time options, while a majority of them are compile-time options.

• Resources, which are objects used internally by TAO, such as a reactor framework that demultiplexes new connection and data requests from a client or synchronization mechanisms used to regulate access to certain parts of the ORB.

• Strategies, which are objects that use the Resource entities to perform various ORB tasks, such as connection management, concurrency, and demultiplexing.

• Factories, which TAO uses to create and consolidate its many resources and strategies into a manageable number of factories that can be (re)configured into the ORB conveniently and consistently by ORB and application developers.

• Environment variables are limited to specifying the interoperable object reference (IOR) and port number of TAO's Naming Service, Trading Service and Implementation Repository. They are limited in flexibility and don't provide the most important configuration hooks necessary to configure TAO for real-time and high-performance applications.

• Command-line options are passed to the ORB initialization factory method, CORBA::ORB_init(), by an application using the standard argc, argv tuple passed to the application's main(). Most of the options that can be exercised through environment variables can also be manipulated through command-line options. Command-line options override the environment variable settings if both are enabled.

• The Service Configurator is a framework that can be used to statically and dynamically configure components into middleware and applications. The information comprising the names of these components and their corresponding options are specified in a service configurator file, whose default file name is svc.conf. The service configurator is opened and processed by the ORB in CORBA::ORB_init(). The service configurator processing is done after all the command-line options have been parsed.

Choosing the Right Approach

• configure the existing components (i.e., resources, strategies and factories) based on the predefined list of alternatives that TAO provides or

• extend the existing factories by providing user-defined components and dynamically load them through the service configurator mechanism.

TAO's ORB Configuration Options

Environment Variables

Environment Variable	Description
NameServicePort which	Specifies which port the Naming Service is listening on for multicast requests.
TradingServicePort which	Specifies which port the Trading Service is listening on for multicast requests.
ImplRepoServicePort which	Specifies which port the Implementation Repository is listening on for multicast requests.

% NameService.exe -ORBEndpoint iiop://localhost:12345

% client.exe -ORBInitRef NameService=iiop://localhost:12345

An explanation of these command-line options appears below.

Command-line Options

Command-line options can be classified into the following groups according to their purposes:

1. Controlling Service Configurator Behavior
2. Controlling Debugging Information
3. Optimizing Request Processing
4. Connection Management and Protocol Selection
5. Miscellaneous Options

1. Controlling Service Configurator Behavior

Option	Description
-ORBSvcConf config filename	Specifies the name of the file used to read service configuration directives via the Service Configurator framework. By default, a service configurator-based application will look for a file named "svc.conf" in the current directory.
-ORBSvcConfDirective directivestring	Specifies a service configuration directive, which is passed to the Service Configurator. You can pass multiple of these options on the same command-line.

2. Controlling Debugging Information

Option	Description
-ORBDebug	Instructs the ORB to print debugging messages from the service configurator framework. This option does not have a value but is used as a toggle to enable or disable debugging messages.
-ORBDebugLevel level	Control the level of debugging in the ORB. Higher numbers generate more output (try 10). The default value of this option is 0.
-ORBVerboseLogging level (0|1|2)	Controls the amount of status data printed on each line of the debug log. Higher numbers generate more output. The default value of this option is 0.
-ORBLogFile Logfilename	Causes all ACE_DEBUG and ACE_ERROR output to be redirected to the designated Logfilename.
-ORBObjRefStyle IOR/URL	Specifies the user-visible style of object references. The IOR style (default) is the conventional CORBA object reference, whereas the URL style looks more like a URL.

3. Optimizing Request Processing

Option	Description
-ORBCDRTradeoff maxsize	Control the strategy to tradeoff between copy vs. no copy marshaling of octet sequences. If an octet sequence is smaller than maxsize (which defaults to ACE_DEFAULT_CDR_MEMORY_TRADEOFF) -- and the current message block contains enough space for it -- the octet sequence is copied instead of appended to the CDR stream.
-ORBCollocation global/per-orb/no	Specifies the use of collocation object optimization. If global is specified (default), objects in the same process will be treated as collocated. If per-orb is specified, only objects in the same ORB are treated as collocated. When no is specified, no objects are treated as collocated.
-ORBCollocationStrategy thru_poa/direct	Specifies what type of collocated object to use. If the thru_poa (default) strategy is used, TAO uses the collocation object implementation that respects POA's current state and policies. When using the direct strategy, method invocations on collocated objects become direct calls to servant without checking POA's status, which can increase performance. If you use the direct strategy, your interfaces must be compiled with the -Gd IDL compiler option.
-ORBNodelay boolean (0|1)	Enable or disable the TCP_NODELAY option (Nagle's algorithm). By default, TCP_NODELAY is enabled.
-ORBRcvSock receive buffer size	Specify the size of the socket receive buffer as a positive, non-zero integer. If not specified, the ACE_DEFAULT_MAX_SOCKET_BUFSIZ default is used.
-ORBSndSock send buffer size	Specify the size of the socket send buffer as a positive, non-zero integer. If not specified, the ACE_DEFAULT_MAX_SOCKET_BUFSIZ default is used.
-ORBStdProfileComponents boolean (0|1)	If 0 then the ORB does not generate the OMG standardized profile components, such as the ORB type and code sets. Notice that the presence of this components is optional in GIOP 1.1 The default value is controlled by a compile-time flag (check orbconf.h).
-ORBSingleReadOptimization boolean (0|1)	This option controls whether TAO's ``single read optimization'' is used when receiving requests. If this option is disabled (0), the ORB will do two reads to read a request: one reads the request header and the other reads the request payload. If this option is enabled (1), the ORB will do a read of size TAO_MAXBUFSIZE, hoping to read the entire request. If more than one request is read they will be queued up for processing later. This option defaults to 1 because it can provide better performance. However, in the case of RT-CORBA, this option should be set to 0. Consider the following scenario: (1) two requests are read from one socket, (2) the additional request is queued, and (3) the ORB uses its Reactor's notification mechanism to wake up the follower threads. If at the same time, however, new requests arrive on others sockets of higher priority the lower priority queued message will be processed before the newly arrived higher priority request since Reactor notifications are given preferences over normal I/O, thereby causing priority inversion.
-ORBDisableRTCollocation boolean (0|1)	This option controls whether the application wants to use or discard RT collocation decisions made by the RT ORB. A value of true disables RT collocation decisions and falls back on the default collocation decisions implemented in the default ORB. This is very useful for applications using the RT ORB and doesn't want to use the RT collocation decisions but fallback on the default decisions for better performance. The default value is 0.

4. Connection Management and Protocol Selection

Option	Description
-ORBDefaultInitRef IOR prefix	This argument allows resolution of initial references not explicitly specified with -ORBInitRef. It requires a URL prefix that, after appending a slash '/' ('|' for the UIOP pluggable protocol) and a simple object key, forms a new URL to identify an initial object reference. The URL prefix format currently supported is based on the standard corbaloc mechanism in the CORBA Interoperable Naming Service.
-ORBDottedDecimalAddresses boolean (0|1)	Use the dotted decimal notation for addresses. This option can be used to workaround broken DNS implementations and may also reduce the time spent resolving IP addresses. By default, this option is disabled (0) since domain names are the standard address notation for IORs.
-ORBEndpoint endpoint	This option is similar to the -ORBListenEndPoints option described below. This option will be deprecated in later versions on TAO since the CORBA specification now defines the -ORBListenEndpoints option instead.
-ORBListenEndpoints endpoint	This option was introduced with the CORBA ORT (Object Reference Template) specification. It instructs a server ORB to listen for requests on the interface specified by endpoint. TAO endpoints are specified using a URL style format. An endpoint has the form: protocol://V.v@addr1,...,W.w@addrN where V.v and W.w are optional protocol versions for each address. An example of an IIOP endpoint is: iiop://hostname:port Sets of endpoints may be specified using multiple -ORBEndpoint options or by delimiting endpoints with a semi-colon (;). For example, -ORBEndpoint iiop://localhost:9999 -ORBEndpoint uiop:///tmp/mylocalsock -ORBEndpoint shmiop://10002 is equivalent to: -ORBEndpoint 'iiop://localhost:9999;uiop:///tmp/mylocalsock;shmiop://10002' Notice the single quotes (') in the latter option specification. Single quotes are needed to prevent the shell from interpreting text after the semi-colon as another command to run. If an endpoint is specified without an addr such as the following: -ORBEndpoint uiop:// -ORBEndpoint shmiop:// then a default endpoint will be created for the specified protocol.
-ORBImplRepoServicePort portspec	Specifies which port the Implementation Repository is listening on for multicast requests. By default, the TAO_DEFAULT_IMPLREPO_SERVER_REQUEST_PORT (10018) is used.
-ORBInitRef ObjectId=IOR	Allows specification of an arbitrary object reference for an initial service. The IOR could be in any one of the following formats: OMG IOR, URL, corbaloc (including uioploc) or file. corbaloc is a multiple end-point IOR understood by ORB::string_to_object() and used as a boot-strapping mechanism by the ORB::resolve_initial_references(). The mappings specified through this argument override the ORB install-time defaults. The file://pathname interprets the contents of the pathname file as an object reference in any of the above formats.
-ORBMulticastDiscoveryEndpoint endpoint	Specifies the endpoint that should be used for locating the Naming Service through multicast. endpoint is of the form ip-number:port-number (e.g., "tango.cs.wustl.edu:1234" or "128.252.166.57:1234"). If there is no ':' in the end_point it is assumed to be a port number, with the IP address being INADDR_ANY.
-ORBNameServicePort portspec	Specifies which port the Naming Service is listening on for multicast requests. By default, the TAO_DEFAULT_NAME_SERVICE_REQUEST_PORT (10013) value is used.
-ORBTradingServicePort portspec	Specifies to which port the Trading Service is listening on for multicast requests. By default, the TAO_DEFAULT_TRADING_SERVICE_REQUEST_PORT (10016) value is used.
-ORBUseIMR boolean (0|1)	This argument specifies that for POAs with the PERSISTENT policy, that the TAO Implementation Repository should be used for notification of startup and shutdown and object references should be changed to use the Implementation Repository also.

5. Miscellaneous Options

Option	Description
-ORBId orb_name	This option allows the name of an ORB to be set to orb_name. The ORBId will be passed to the ORB_init() method to differentiate coexisting ORBs (when there are more than one ORBs).
-ORBServerId server_id	This option allows setting a name/id to a server to uniquely identify a server to TAO's Implementation Repository.
-ORBDaemon	Specifies that the ORB should daemonize itself, i.e., run as a background process. This option is only meaningful on OS platforms that support daemonization.

The Service Configurator File

1. Default Resource and Advanced Resource Factories. This factory controls the creation of configurable resources used by TAO's ORB core. The resource factory is responsible for constructing and providing access to various resources used by the ORB irrespective of whether they perform client or server roles. ORB resources include reactors, protocol factories, message flushing strategies, connection purging strategies and different IOR parsers.

2. Server Strategy Factory. This factory creates various strategies of special utility to the ORB that is useful for controlling the behavior of servers. This factory is responsible for creating strategies useful for server objects like the concurrency strategy and the request demultiplexing strategies used by the POA.

3. Client Strategy Factory. This factory creates various strategies of special utility to the ORB, useful for controlling the behavior of clients. This factory is responsible for creating strategies useful for clients such as request multiplexing strategies, wait strategies, connect strategies etc.

A svc.conf file is not required to run TAO applications since TAO provides a set of default values for strategies useful for the most common use cases, i.e., the default values are set for all options. When a TAO application calls CORBA::ORB_init() it will try to find the svc.conf file. If found, TAO will parse and process the directives in the file; if not found, the default value for the default components will be used.

1. Default and Advanced Resource Factories

Resource Factory	Description
Resource Factory	Unless configured otherwise, this is the default resource factory used by the ORB.The resource factory is responsible for creating and providing access to various resources used by the server and client ORBs. The resources managed by this factory include creation of acceptor and connector registries, choice of data flushing strategy, limits for connection resource management, types of CDR buffers used for marshalling and demarshalling data, and different IOR parsers.
Advanced Resource Factory	This factory provides more advanced configuration options in the addition to all the features of the default resource factory. The advanced resource factory gives more control than the default resource factory over the type of resources used and how those resources are accessed. In addition to the options provided by the default resource factory, the advanced resource factory provides options that allow selecting different reactors, choosing different transport mechanisms and selecting the right connection purging strategy to maintain limits on resources used. The advanced resource factory was created to allow more advanced options while keeping the footprint of the default resource factory small. The advanced resource factory inherits from the default resource factory and accepts all of its options in addition to its own.
Qt Resource Factory	This is a specialized resource factory providing the means for integrating with the Qt GUI toolkit from Trolltech.
Xt Resource Factory	This is a specialized resource factory providing the means for integrating with the X Window System's Xt Intrinsics toolkit.

1.1. Resource_Factory

static Resource_Factory "[list of options]"

will load the default resource factory with the options listed within the double quotes. The following table shows the list of possible options that can be specified within the double quotes in the above directive. There is an online example of how this is used in TAO.

Option	Description
-ORBReactorMaskSignals 0/1	ACE select reactors mask signals during upcalls to the event handlers. This is only useful if the application is going to trap those signals and handle them in any special way. Disabling the mask can improve performance by reducing the number of kernel level locks.
-ORBProtocolFactory factory	Specify which pluggable protocol factory to load. By default, only the factory for the IIOP protocol (IIOP_Factory is loaded. For example, if some protocol called Foo whose factory was called Foo_Factory was available, then it could be loaded into TAO by specifying -ORBProtocolFactory Foo_Factory in the service configurator file. The Foo pluggable protocol would then be available for use.
-ORBIORParser parser	Name an IOR Parser to load. IOR Parsers are used to interpret strings passed to ORB::string_to_object(). By default the ORB can handle multiple string formats, including IOR:, corbaloc:, corbaname:, and file:. The application developer can add new IOR formats using this option.
-ORBConnectionPurgingStrategy type	Opened connections are added to the transport cache so they can be reused. However, if a process continues to run and these connections are not reused, the cache will continue to grow. Therefore, before each new connection, the cache is checked and purged if it has reached the limit specified by the -ORBConnectionCacheMax option or the system default if that option was not used. The possible values for type are lru, lfu, fifo and null. The default is LRU (Least Recently Used). The others LFU (Least Frequently Used), FIFO (First In First Out), and null (No connections are purged) are contained within the TAO Strategies library.
-ORBConnectionCacheMax limit	The transport cache will grow to a maximum of the specified limit. The default is system dependent, but can be overridden at compile-time by defining the preprocessor macro TAO_CONNECTION_CACHE_MAXIMUM.
-ORBMuxedConnectionMax number	The transport cache allows only specified number of connections-per-QoS property to be added to connection cache. Threads not getting the connections will wait for the connections to be released. This option is more useful for transports using a muxed connection strategy and want control over the number of connections that are created by the active threads.
-ORBConnectionCachePurgePercentage percent	If the transport cache is purged, the specified percentage (20 by default) of the total number of connections cached will be closed.
-ORBConnectionCacheLock locktype	Specify the type of lock to be used by the Connection Cache. Possible values for lock type are thread, which specifies that an inter-thread mutex is used to guarantee exclusive access, and null, which specifies that no locking be performed. The default is thread.
-ORBCorbaObjectLock locktype	Specify the type of lock to be used by CORBA::Object. The lock is needed within the CORBA object to synchronize the state when the same object is shared by multiple threads. Possible values for lock type are thread, which specifies that an inter-thread mutex is used to guarantee exclusive access, and null, which specifies that no locking be performed. The default is thread. The null lock option is useful when there is only one thread in the system. This option can be used to minimize the amount of memory consumed by the locks in applications where locks are not needed. The memory growth problem gets particularly exacerbated for applications dealing with hundreds and thousands of objects.
-ORBObjectKeyTableLock locktype	Specify the type of lock to be used by the ObjectKey table. ObjectKey table keeps track of the ObjectKeys that are generated and made available through IORs. The table manages the life time of the object keys within the ORB through a reference counting mechanism. Possible values for lock type are thread, which specifies that an inter-thread mutex is used to guarantee exclusive access, and null, which specifies that no locking be performed. The default is thread.
-ORBFlushingStrategy type	By default TAO provides three strategies to flush queued messages. The leader_follower strategy uses the Reactor and non-blocking I/O to send the outgoing messages, this strategy participates in the Leader/Followers protocol to synchronize access to the Reactor. The reactive strategy uses the Reactor but does not take part in the Leader/Followers protocol, thus it is better used only in single threaded applications. Finally, the blocking strategy flushes the queue as soon as it becomes "full", and blocks the thread until all the data is sent.

1.2. Advanced_Resource_Factory

dynamic Advanced_Resource_Factory Service_Object *
TAO_Strategies:_make_TAO_Advanced_Resource_Factory () "-ORBReactorType select_st"

It can also be loaded statically by doing the following:

• Add #include "tao/Strategies/advanced_resource.h" to the file containing main().
• Link the TAO_Strategies library into the executable.
• Specify a service configurator directive of the form: static Advanced_Resource_Factory "-ORBReactorType select_st"

Loading the Advanced_Resource_Factory disables the Resource_Factory. Any directives for the Resource_Factory will have no effect (and generate warnings telling you so). The following table lists the options that can be provided in double quotes. An example is available online that shows how to specify this option in the svc.conf file.

Option	Description
-ORBReactorType which	Specify what kind of reactor the ORB uses. The default reactor is the ACE_TP_Reactor. which Reactor select_mt Use the multi-thread select-based reactor. select_st Use the single-thread select-based reactor. fl Use the FLReactor (FLTK-based). wfmo Use the WFMO reactor (Win32 only). msg_wfmo Use the MsgWFMO reactor (Win32 only). tp Use the ACE_TP_Reactor, a select based thread-pool reactor which is the MT_NO_UPCALL means use a client connection handler that participates in the leader-follower model like MT, but, like RW, does not allow handling of nested upcalls within the waiting thread. default.
-ORBReactorThreadQueue which	Applies only to the ACE_TP_Reactor, i.e., when -ORBReactorType = tp, and specifies the order, last-in-first-out (which = LIFO), the default, or first-in-first-out (which = FIFO), in which waiting threads are selected to run by the ACE_Select_Reactor_Token.
-ORBInputCDRAllocator which	Specify whether the ORB uses locked (which = thread) or lock-free (which = null) allocators for the incoming CDR buffers. Though null should give the optimal performance; we made the default thread. TAO optimizations for octet sequences will not work in all cases when the allocator does not have locks (for example if the octet sequences are part of a return value). Using locked allocators also allows the users to take advantage of the TAO octet sequence extensions to preserve the buffer after the upcall.
-ORBAMHResponseHandlerAllocator which	Specify whether the ORB uses locked (which = thread) or lock-free (which = null) allocators for the AMH response handlers.
-ORBAMIResponseHandlerAllocator which	Specify whether the ORB uses locked (which = thread) or lock-free (which = null) allocators for the AMI response handlers.
-ORBReactorRegistry registry_type	This option is no longer supported. The Advanced Resource Factory will emit an error if you attempt its use.

2. Server_Strategy_Factory

• The concurrency strategies control the thread creation flags and other concurrency related behaviors.

• The demuliplexing strategies are used to locate servants inside the POA that are responsible for handling requests.

Typically, the following options are set via the service configurator (svc.conf) file. The following line in the svc.conf file (all in one line)

static Server_Strategy_Factory "[list of options]"

would load all the options listed within "". An example is available online that shows how to specify this option in the svc.conf file.

Option	Description
-ORBConcurrency which	Specify which concurrency strategy to use. Range of values is reactive for a purely Reactor-driven concurrency strategy or thread-per-connection for creating a new thread to service each connection. The default is reactive.
-ORBThreadPerConnectionTimeout milliseconds	In many platforms it is impossible to interrupt the server threads created by the thread-per-connection model. This is because these threads are blocked in read() operations (and not in select()). As a workaround, the server threads periodically poll the ORB to find out if they should shutdown. This option controls the period of the polling, expressed in milliseconds. Applications that do not shutdown, or that can otherwise ensure that no server threads will be running at shutdown (for example if all the clients terminate before the server) can disable the polling using the magic value INFINITE. If the option is not provided then the ORB uses the compile-time flag TAO_DEFAULT_THREAD_PER_CONNECTION_TIMEOUT, this flag also expresses the time in milliseconds (as a string constant) and the magic value "INFINITE" can be used to disable polling entirely. This yields a slight performance improvement (around 1%).
-ORBActiveObjectMapSize active object map size	Specify the size of the active object map. If not specified, the default value is 64.
-ORBUseridPolicyDemuxStrategy user id policy based demultiplexing strategy	Specify the demultiplexing lookup strategy to be used with the user id policy. The demultiplexing strategy can be one of dynamic or linear. This option defaults to using the dynamic strategy.
-ORBSystemidPolicyDemuxStrategy system id policy based demultiplexing strategy	Specify the demultiplexing lookup strategy to be used with the system id policy. The demultiplexing strategy can be one of dynamic, linear, or active. This option defaults to use the dynamic strategy when -ORBAllowReactivationOfSystemids is true, and to active strategy when -ORBAllowReactivationOfSystemids is false.
-ORBUniqueidPolicyReverseDemuxStrategy unique id policy based reverse demultiplexing strategy	Specify the reverse demultiplexing lookup strategy to be used with the unique id policy. The reverse demultiplexing strategy can be one of dynamic or linear. This option defaults to using the dynamic strategy.
-ORBAllowReactivationOfSystemids allows reactivation of system ids	Specify whether system ids can be reactivated, i.e., once an id that was generated by the system has been deactivated, will the user reactivate a new servant using the old id. If the user is not going to use this feature, the IORs can be shortened, an extra comparison in the critical upcall path removed, and some memory on the server side can be saved. The ORBAllowReactivationOfSystemids can be 0 or 1. This option defaults to 1.
-ORBActiveHintInIds adds an active hint in ids	Specify whether an active hint should be added to ids. With active hints, ids can be found quickly. However, they lead to larger IORs. Note that this option is disregarded if -ORBAllowReactivationOfSystemids is set to 0. The -ORBActiveHintInIds can be 0 or 1. This option defaults to 1.
-ORBPoaMapSize poa map size	Specify the size of the POA map. If not specified, the default value is 24.
-ORBPersistentidPolicyDemuxStrategy persistent id policy based demultiplexing strategy	Specify the demultiplexing lookup strategy to be used with the persistent id policy. The demultiplexing strategy can be one of dynamic or linear. This option defaults to using the dynamic strategy.
-ORBTransientidPolicyDemuxStrategy transient id policy based demultiplexing strategy	Specify the demultiplexing lookup strategy to be used with the transient id policy. The demultiplexing strategy can be one of dynamic, linear, or active. This option defaults to using the active strategy.
-ORBActiveHintInPOANames adds an active hint in poa names	Specify whether an active hint should be added to POA names. With active hints, POA names can be found quickly. However, they lead to larger IORs. The -ORBActiveHintInPOANames can be 0 or 1. This option defaults to 1.
-ORBThreadFlags thread flags	Specify the flags used for thread creation. Flags can be any logical-OR combination of THR_DETACHED, THR_BOUND, THR_NEW_LWP, THE_SUSPENDED. The default is THR_BOUND | THR_DETACHED .
-ORBPOALock lock type	Specify the type of lock to be used for POA accesses. Possible values for lock type are thread, which specifies that an inter-thread mutex is used to guarantee exclusive access, and null, which specifies that no locking be performed. The default is thread.

3. Client_Strategy_Factory

Typically, the following options are set via the service configurator (svc.conf) file. The following line in the svc.conf file (all in one line)

static Client_Strategy_Factory "[list of options]"

would load all the options listed within "". An example is available online that shows how to specify this option in the svc.conf file.

Option	Description
-ORBProfileLock which	Specify the kind of synchronization primitive for the Profiles. Default is thread, which means that a regular thread mutex is used. The second option is null, which means a null lock is used. This makes sense in case of optimizations and is allowed when no forwarding is used or only a single threaded client.
-ORBClientConnectionHandler MT | ST | RW / MT_NOUPCALL -ORBWaitStrategy MT / ST / RW / MT_NOUPCALL	ST means use the single-threaded client connection handler, i.e., the leader follower model will not be used. However, ST does support nested upcalls and handling of new requests while waiting for the reply from a server. MT means use the multi-threaded client connection handler which uses the leader follower model. This model allows the use of multiple threads with a single Reactor. RW selects a strategy that simply blocks in recv() when waiting for a response from the server instead of waiting in the Reactor. The RW strategy only works when the application does not have to worry about new request showing up when waiting for a response. Further, this strategy cannot be used with Asynchronous Method Invocation (AMI) calls. Therefore, this strategy is appropriate only for "pure" synchronous clients. Note that applications with nested upcalls are not "pure" synchronous clients. Also note that this strategy will only effect two way calls, since there is no waiting for one way calls. This strategy can also be used in an application that is both a client and a server if the server side is handled by a separate thread and the client threads are "pure" clients. MT_NOUPCALL means use a client connection handler that participates in the leader-follower model like MT, but, like RW, does not allow handling of nested upcalls within the waiting thread. Note that with this strategy it is possible to "run out of threads" in a thread pool, and that TAO doesn't grow thread pools. Unlike RW, this does not require -ORBTransportMuxStrategy EXCLUSIVE. Default for this option is MT.
-ORBTransportMuxStrategy EXCLUSIVE | MUXED	EXCLUSIVE means that the Transport does not multiplex requests on a connection. At a time, there can be only one request pending on a connection. MUXED means that Transport multiplexes more than one request at the same time on a connection. This option is often used in conjunction with AMI, because multiple requests can be sent "in bulk." Default for this option is MUXED.
-ORBConnectStrategy type	TAO provides three strategies to connect to remote servers. The default leader_follower strategy uses the Reactor and non-blocking connects to connect and this strategy participates in the Leader/Followers protocol to synchronize access to the Reactor. The reactive strategy uses the Reactor for non-blocking connects but does not take part in the Leader/Followers protocol, thus it is better used only in single threaded applications. Finally, the blocked strategy as the name implies, blocks the thread until connection is complete. Some of the protocols in TAO (such as SHMIOP and SSLIOP) can only use the blocked strategy.

Back to the TAO component options and tuning documentation.