ORB & ORB Core

We are fully compliant with OMG 2.2 / 2.3 spec.

When using the thread-per-connection concurrency model, if some client leave the socket connection open without sending any request, the server will crash on NT. This is because we are doing a blocking recv when a server connection handler acts as an active object, and the recv won't break out until the process gets kill by the OS. This is especially a problem on NT because on shutdown, NT close down the socket service, which cause the blocking recv to unblock at which point, these threads try to access the already destroyed ORB resources. A temporary workaround is to close the sockets when the ORB is shutting down. But this is not portable and only works on NT.

Object references for objects dynamically created within a server may not have proper host. When an object is dynamically created and its object reference returned, it simply has to "guess" at the host information that is returned in the IIOP Profile. Currently, it guesses using the host name, which is a reasonable guess in most cases. However, if there are multiple interfaces on a machine and they have different host names, it is possible that the desired effect will not be realized, i.e., the connection to that new object may use a different interface from the original object. Currently the only way to change this is to use the -ORBEndpoint option to manually specify that dynamically-created objects bind to a specific interface so that their IIOP Profile has the desired hostname. A more desirable fix is being investigated.

Trying to figure out a better resource management scheme. Resouces here include ORB, POA, connections, profiles.... that provide services for CORBA invocations.

[STATUS]: The current version keeps very few objects managed by the resource factory. Most are ORB specific. It seems like the correct implementation is to make the few remaining resources (such as the Reactor) a per-ORB-per-thread entity.

Support new concurrency models, e.g., Thread-per-Request, etc..

Robustness improvements to connection cache so that it will purge old connections when there are no more slots or sockets are available.

[STATUS]: The current version does go a long way to purge old connections. However, all socket creation points are not covered and acceptor-side sockets are not purged.

The ORB was running into some concurrency problems if client thread(s) ran before the server thread(s) got to run the event loop. This problem with the internal Leader/Followers model has been fixed.

The ORB now supports nested calls to the event loop, i.e., the event loop can be called from the servant code by calling ORB::run() or ORB::perform_work().

TAO_ORB_Core_instance() returns the orb core of the default orb (the first orb created by the user). This may not be the orb that the user is interested in. The better approach is myorb->orb_core().

Added an optional argument to resolve_initial_references() that allows the user to specify a timeout (an upper bound on the time-to-wait for a response from the ORB's multicast "search" for a running server). If no timeout value is specified by the user, TAO_DEFAULT_SERVICE_RESOLUTION_TIMEOUT is used.

ORB::perform_work and ORB::work_pending are now implemented. Some remaining kinks in these methods have recently been fixed.

Provides dynamically linked wholesale assignment of ORB strategies for communication, concurrency, demultiplexing, scheduling, and dispatching using the ACE Service Configurator framework.

Supports several concurrency models out of the box: Reactive, Thread-per-Connection, and ORB-per-thread. The ORB-per-thread design is optimized for real-time I/O subsystems. (See: Configuration Guide.)

Supports resolve_initial_references("<CORBA Service>") using ACE support for multicast. (TAO proprietary.)

Support both native C++ exceptions and CORBA::Environment based exceptions handling.

Support for TAO proprietary -ORBgioplite command-line option. When this option is enabled the ORB removes a few fields of the GIOP messages that are normally not used, such as the version numbers, the magic 'GIOP' string, the service context, the Principal object, etc. This option give us a slight performance improvement but it is important for extremely low-latency systems (such as avionics), that fortunately have tightly controlled environments so this kind of optimization is safe to use.

The buffers for outgoing CDR streams are allocated from TSS memory pools, reducing locking on the critical path.

Several optimizations on the critical path have been implemented, carefully removing excesive locking, memory allocations and data copying. In some cases special demarshaling and marshaling functions where written for the request headers.

Adding a new option into TAO_Resource_Factory to control the internal lock used by ORB's reacotr. With "-ORBreactorlock null" added into svc.conf, you can eliminate the token inside the Select_Reactor inside the ORB even on multi-threaded platforms. This eliminate some overheads caused by synchronizing access to the Select_Reactor. Usually, if you have TSS ORB and are using reactive concurrency startegy, the ORB are not accessed by multiple threads, then, you can safely turn the lock off.

Strategized the connection management scheme so that we don't always have to pay the price of a look up in the connection cache. Basically, we "hold" a service handler for a string of requests.

There is no need to call ORB::open if the port is 0. It will automatically be called when the first stub is created.

The ORB now handles nested upcalls correctly. See this for details on the design of the solution.

Added optimization for collocated objects. This optimization enables TAO to bypass communication layers and talks to collocated objects directly.

Making the collocation table configurable. We can either use a global collocation table to share objects among ORBs, or use the per-ORB collocation table.

Implement the inheritance mechanism in Default_Server_Connection_Handler to access the parent's POA. This is necessary when we are using thread-per-connection concurrency model.

It is often desireable for a server to start up and not have to specify the TCP port number on which the ORB will listen, i.e., let the OS decide. While this works properly (by providing an argument such as `-ORBEndpoint iiop://localhost:0'), the actual port number used by the server won't be available after the server starts listening. TAO now tries to bind the address when a port set to zero is issued so it can get the actual address to publish the IOR for clients' use.

Broke the tight coupling between CORBA_Object and IIOP_Object so that multiple CORBA_Objects can share a single IIOP_Object. This has a big win in _narrow operations.

The ORBs manipulation of object keys and object ids is now consistent. Canonically, everything is managed as an opaque sequence of octets. Conversion to/from strings is permitted, with non-printables turning into a trigraph \hl where h is the high nibble digit in hex, and l is the low nibble in hex.

CORBA::ORB::run() should be able to be called multiply in the same execution path now.

Fixed the LOCATION_FORWARD capabilities to work as described in the CORBA 2.1 and the POA specification.

Support for -ORBSndSock and -ORBRcvSock ORB options. See options documentation for details.

Support for connections pre-establishment using the -ORBPreconnect option. This allows connections to be established before any CORBA requests are made. See options documentation for details.

Placed an optimization in IIOP::Profile that should speed up invocations on the client side rather substantially. This was done by caching an instance of ACE_INET_Addr in the private portion of Profile because the cost of constructing one for every invocation (in TAO_GIOP_Invocation::start) was simply enormous--the construction was something like 100 cycles on Solaris. This is all because deep down this ends up calling gethostbyname(), which can be very costly. Of course, this is platform-dependent, so the improvements may not be as great on a different platform.

Eliminated need for CORBA::Object to keep a pointer to its orb sitting around anywhere.

Tested CORBA_ORB::shutdown() as a manner in which a thread of control can request that CORBA_ORB::run() should return and no longer service requests. It only honors a wait_for_completion argument of FALSE right now because we haven't fully explored the issues which surround doing all the completion.

Implemented CORBA_ORB::shutdown() as a manner in which a thread of control can request that CORBA_ORB::run() should return and no longer service requests.

Support for the -ORBInitRef option. This allows run-time specification of an ObjectId<->IOR mapping. It is used by resolve_initial_references() and overrides the ORB install-time defaults.

minimal support for CORBA Contexts. This is an inherently un-typesafe feature, and many believe it will disappear from CORBA eventually, but in order to make _create_request() compliant, we have added a CORBA_Context class. The only permissible value for a Context pointer passed as an argument to _create_request is 0. If a non-zero pointer is passed, a NO_IMPLEMENT exception is raised.

Support configuring TAO's component as both static and dynamic services. Improve robustness of setting default svc.conf entries. See Configuration Document for details.

TAO understands Interoperable Naming Service's corbaloc: and corbaname: IOR format.

Added Vendor ID and TAO-specific information to the CORBA_SystemException minor status component. The TAO-specific information currently consists of location (in the TAO source code) and errno indications. See tao/corbafwd.h for values. CORBA_SystemException::print_exception_tao_ () should be used to print system exceptions. If a known (expected) errno had been received, then it is printed. Otherwise, the low 7 bits of the errno are printed (in decimal). They can be a bit tricky to interpret, for example, because it might have been generated on the server. We only maintain the low 7 bits because of size restrictions on the minor status component.

The CORBA::ORB_init() function returns the same ORB if it is called twice with the same ORBid parameter or if the "-ORBid value" option is present in the argv-list. Please consult the CORBA specification for more details.

We implemented GIOP 1.1, including the support for tagged components in IIOP profiles.

Added CORBA compliant collocated stubs implementation. The new implementation now query POA for permission to proceed thus fixed many potentially subtle problems. The original collocation implementation is still supported using by specifying the -ORBCollocationStrategy direct command option (because the original scheme has slightly less method invocation overhead.)

Implemented CORBA::ORB::destroy() method. See the CORBA 2.3a specification for details about this method.

Implemented shared memory tranpost SHMIOP. The performance of shared memory transport is still not optimal but our next step is to improve its performance.

The Typecode creation functions that were in the ORB have been moved (in accordance with the new Interface Repository spec in CORBA Components volume III) to a separate interface, CORBA::TypeCodeFactory. This has been implemented as a DLL in the directory TAO/orbsvcs/IFR_Service (the Typecode factory is used by the Interface Repository, but it can also be used on its own). To make it available, TAO must be compiled either with the compiler option interface_repo=1 or with #define TAO_HAS_INTERFACE_REPOSITORY 1 uncommented in TAO/tao/orbconf.h. Then build the TypeCodeFactory files in the directory mentioned above. In the application, a call to resolve_initial_references ("TypeCodeFactory") will fetch the object reference, which should then be narrowed from CORBA::Object_ptr.