CORBA 2.6 Programmer's Guide for C++
Taking Advantage of Concurrency
If your application has the potential for concurrency (that is, it includes thread-blocking operations but
not process-blocking operations), you may be able to use multithreading to reduce the number of
processes required to handle a given workload. For details, refer to Writing Multithreaded Applications.
If your application performs process-blocking operations, you can take advantage of process concurrency
by using server pools.
Adjusting Process Priorities
In general, processes that provide services should have higher priority than processes that request those
services. More specifically, consider the process flow as a river at whose delta are services (both COS
and application) or entity objects, whose tributaries are control objects, and whose source streams are
Comm Server, TCP/IP, and similar processes that are conduits for client requests. The delta should have
higher priority than the tributaries, and the tributaries should have higher priority than the source streams.
Adjusting Message-Buffer Sizes
Application performance is affected by the size of message buffers, particularly for remote operations.
The most efficient buffer sizes are neither extremely big nor extremely small.
You should design your IDL interface so that your messages are of reasonable size. For C++ programs,
you can use the administrative interfaces to adjust buffer sizes at run time through the io_size
configuration option. In general, large messages perform better with larger buffers, whereas smaller
messages perform acceptably well with the default buffer size.
Caution: All processes that use GIOP over TS/MP or GIOP over the Guardian file systemthat is,
all processes that use a protocol other than TCP/IPto communicate with each other must
share the same io_size value. Therefore, to change this value at run time, you must
first stop all processes that use these protocols, change the io_size value, and then
restart all processes. All processes can include processes associated with different
installations of NonStop CORBA, possibly even on different NonStop systems, if they
use GIOP over TS/MP or GIOP over the Guardian file system to communicate with each
other.
Because the io_size value cannot be changed for Java programs, you cannot adjust
this value at run time for any C++ processes that communicate with processes written in
Java.
Chapter 8. Writing Multithreaded
Applications
Chapter 10. Porting CORBA
Applications to NonStop CORBA