CORBA 2.6 Programmer's Guide for Java

Parallel Processing and Its Implications
NonStop CORBA can run application servers as server pools. This style of implementation allows many
processes to act as one logical server; each new unit of work goes to the next available free server
process in the pool. Server processes can run in different processors to allow for parallel processing.
In general, the implementation of an object in a server pool is transparent to the programmer except for
the following characteristics:
Class data for an object class applies only to the object instances in one process, not to the entire
object class (which might have instances in other processes).
●
TS/MP load balancing is available only for stateless servants.●
If you use server pools, you must decide how to provide for stateless requests when possible and stateful
requests when necessary. In stateless processing, a series of operations on the same object can result in
requests to different processes in a server pool. In stateful processing, operations on the same object are
handled by the same process, allowing the server to treat the requests as a series and to coordinate
concurrent access to the same object by different clients.
Designing a Server
Most server design decisions depend on the characteristics and relationships among objects that will run
in the server. To design a server, you consider issues such as:
Object references. How to tailor the construction of an object referencethe handle by which a
client refers to an existing objectto meet application requirements for persistence, to support either
one or multiple instances of a class in a process, and to satisfy server-pool requirements.
●
Concurrency. Whether the server requires threads.●
Parallelism. Whether the server can run as a server pool.●
Designing a Client
To design a client, you consider issues such as:
Local/remote transparency. Whether the location of an object must be transparent to the client.
By using certain calls for object creation and invocation, you can ensure that the same code will
operate correctly regardless of where the object is.
●
Static invocation or dynamic invocation. For example, whether the client will use a predictable
set of object interfaces or might find out about new interfaces at run time.
●
Object lifecycle. Issues such as creating, locating, and releasing objects, including how to use the
Naming Service.
●
Server selection. For example, whether to request a specific server or use any server that can host●