CORBA 2.3.7 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.
Prev Up Next
Chapter 8. Writing Multithreaded
Applications
Home
Chapter 10. Porting CORBA
Applications to NonStop CORBA