Corporate Info  |  News  |  Solutions  |  Products  |  Partners  |  Services  |  Events  |  Download  |  How To Buy
	http://www.oracle.com/technology/documentation/index.html   |   Site Map   |   Search   |   PDF Files   |   Contact   |   Glossary
Tuxedo Doc Home   |   Programming   |   Topic List   |   Previous   |   Next   |   Contents

   Programming a BEA Tuxedo Application Using C

The events that occur in a server when a multithreaded and multicontexted application is active can be described in three phases:

• Start-up Phase

• Work Phase

• Completion Phase

Start-up Phase

What happens during the start-up phase depends on the value of the MINDISPATCHTHREADS and MAXDISPATCHTHREADS parameters in the configuration file.

If the value of MINDISPATCHTHREADS is . . .	And the value of MAXDISPATCHTHREADS is . . .	Then . . .
0	> 1	The BEA Tuxedo system creates a thread dispatcher. The dispatcher calls tpsvrinit() to join the application.
> 0	> 1	The BEA Tuxedo system creates a thread dispatcher. The dispatcher calls tpsvrinit() to join the application. The BEA Tuxedo system creates additional threads for handling service requests, and a context for each new thread. Each new system-created thread calls tpsvrthrinit(3c) to join the application.

In this phase, the following activities occur:

• Multiple client requests to one server are handled concurrently in multiple contexts. The system allocates a separate thread for each request.

• If necessary, additional threads (up to the number indicated by MAXDISPATCHTHREADS) are created.

• The system keeps statistics on server threads.

Server-dispatched Threads Are Used

In response to clients' requests for a service, the server dispatcher creates multiple threads (up to a configurable maximum) in one server that can be assigned to various client requests concurrently. A server cannot become a client by calling tpinit().

Each dispatched thread is associated with a separate context. This feature is useful in both conversational and RPC servers. It is especially useful for conversational servers which otherwise sit idle, waiting for the client side of a conversation while other conversational connections are waiting for service.

This functionality is controlled by the following parameters in the SERVERS section of the UBBCONFIG(5) file and the TM_MIB(5).

UBBCONFIG Parameter	MIB Parameter	Default
MINDISPATCHTHREADS	TA_MINDISPATCHTHREADS	0
MAXDISPATCHTHREADS	TA_MAXDISPATCHTHREADS	1
THREADSTACKSIZE	TA_THREADSTACKSIZE	0 (representing the OS default)

• Each dispatched thread is created with the stack size specified by THREADSTACKSIZE (or TA_THREADSTACKSIZE). If this parameter is not specified or has a value of 0, the operating system default is used. On a few operating systems on which the default is too small to be used by the BEA Tuxedo system, a larger default is used.

• If the value of this parameter is not specified or is 0, or if the operating system does not support setting a THREADSTACKSIZE, then the operating system default is used.

• MINDISPATCHTHREADS (or TA_MINDISPATCHTHREADS) must be less than or equal to MAXDISPATCHTHREADS (or TA_MAXDISPATCHTHREADS).

• If MAXDISPATCHTHREADS (or TA_MAXDISPATCHTHREADS) is 1, then the dispatcher thread and the service function thread are the same thread.

• If MAXDISPATCHTHREADS (or TA_MAXDISPATCHTHREADS) is greater than 1, any separate thread used for dispatching other threads does not count toward the limit of dispatched threads.

• Initially, the system boots MINDISPATCHTHREADS (or TA_MINDISPATCHTHREADS) server threads.

• The system never boots more than MAXDISPATCHTHREADS (or TA_MAXDISPATCHTHREADS) server threads.

Application-created Threads Are Used

Using your operating system functions, you may create additional threads within an application server. Application-created threads may:

• Operate independently of the BEA Tuxedo system

• Operate in the same context as an existing server dispatch thread

• Perform work on behalf of server dispatch contexts

Some restrictions govern what you can do if you create threads in your application.

• Servers may not become clients by calling tpinit().

• Initially, application-created server threads are not associated with any server dispatch context. An application-created server thread may call tpsetctxt(3c) (and pass it a value returned by a previous call to tpgetctxt(3c) within a server-dispatched thread) to associate itself with that server-dispatched context.

• An application-created server thread cannot call tpreturn() or tpforward(). When an application-created server thread has finished its work, it must call tpsetctxt(3c) with the context set to TPNULLCONTEXT before the originally dispatched thread calls tpreturn().

BBL Verifies Sanity of System Processes

The BBL periodically checks servers. If a server is taking too long to execute a particular service request, the BBL kills that server. (If specified, the BBL then restarts the server.) If the BBL kills a multicontexted server, the other service calls that are currently being executed are also terminated as a result of the process being killed.

The BBL also sends a message to any process or thread that has been waiting longer than its timeout value to receive a message. The blocking message receive call then returns an error indicating a timeout.

For each server, the BEA Tuxedo system maintains statistics for the following information:

• Maximum number of server-dispatched threads allowed

• Number of server-dispatched threads currently in use (TA_CURDISPATCHTHREADS)

• High-water mark of concurrent server-dispatched threads since the server was booted (TA_HWDISPATCHTHREADS)

• Number of server-dispatched threads historically started (TA_NUMDISPATCHTHREADS)

Userlog Maintains Thread-specific Information

For each thread in each application, userlog(3c) records the following identifying information:

process_ID.thread_ID.context_ID

Placeholders are printed in the thread_ID and context_ID fields of entries for non-threaded platforms and single-contexted applications.

The TM_MIB(5) supports this functionality in the TA_THREADID and TA_CONTEXTID fields in the T_ULOG class.

When the application is shut down, tpsvrthrdone(3c) and tpsvrdone(3c) are called to perform any termination processing that is necessary, such as closing a resource manager.

• What Are Multithreading and Multicontexting

• Design Considerations for a Multithreaded and Multicontexted Application

• Writing Code to Enable Multicontexting and Multithreading in a Server

• Writing a Multithreaded Server