## Table of Contents

- Current Status
- Known Issues
- Ongoing work
- Future Work
- Completed Work

# ORB & ORB Core

Point of contact: Balchandran Natarajan

Last Update: 2006/02/13 16:24:31

### Current status:

- We are compliant with OMG's CORBA 2.6 specification.

Back to TOC

### Known issues:

- TAO's support for wstring as per GIOP 1.2 rules are not perfect. There have been reported interoperability problems.

- The multi-profile parsing code in TAO hasnt been tested well and we have been able to identify some issues with it. The details are documented in our bug tracking system under id's 1237, 1238and1239

- Applications using the distributed callback paradigm could see crashes if they use multiple nested upcalls. The nested upcalls sets of a stack growth and crashes when it runs out of stack space. This happens when an upcall as a part of the request leads to another request. The client thread waiting for the reply in the reactor could in turn process yet another request to build up the stack. The unbounded growth on the stack leads to crash failures.

Back to TOC

### Ongoing Work:

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

- Improvement to connection cache on the acceptor side so that it will purge old connections when there are no more slots or sockets are available. The connection cache does good job of purging things on the connector side

- Prevent unbounded stack growth that leads to a failure in situations explained in known issues.

Back to TOC

### Future work:

- Performance bottlenecks:

1. Need to identify performance bottlenecks. Looks like TAO has slowed down a bit over the past two betas. Need to identify the bottlenecks before improving the performance.

2. Its a known fact that thread-per-connection is faster than the reactive model, even for single threaded cases. Need to identify portions of the reactor that slows down things and fix them or create a fast path in the ORB just using plain vanilla select for the server.

3. In the output data path, the CDR creates the message block and all other associted things on TSS. If we could change the CDR to first create them on the stack and then move the data to TSS we could achieve better performance for small messages.

- Features:

1. Implement DP-CORBA specification

2. Implement TII specification.

Back to TOC

### Completed Work:

- Implemented a connection timeout policy in the ORB. This is useful for applications to set a timeout value associated with connection establishment. The name of the policy is `TAO::CONNECTION_TIMEOUT_POLICY_TYPE` and is proprietary to TAO. It comes as a prt of the TAO_Messaging library. Please see `$TAO_ROOT/tests/Connection_Timeout` for an example of how to use this feature.

- Implemented non-blocking connects with three different strategies for connection establishment. The details of the strategies and the related documentation can be found here.

- Deprecated the option -ORBConnectionCachingStrategy. The option -ORBConnectionPurgingStrategy fills in the role of the deprecated strategy.

- Deprecated the option -ORBResources.

- The connectors have been moved to the lanes.

- Fixed stack recursion problems that occurs, when a thread flushing a reply by entering the reactor starts processing incoming requests.

- Fixed connection handling and connection closing problems, when a write call to a remote host fails.

- Moved the allocators used for allocating memory for the incoming data path to the lanes. Only allocators on the incoming data path are moved into the lanes. Allocators on the outgoing data path are still on a per-orb basis. Since the outgoing data path uses memory from the TSS, moving them to the lanes is not necessary.

- Added an option, -ORBSingleReadOptimization that allows users to turn on or turn off the single read optimization. This is useful for RTCORBA server threads to avoid priority inversions. Buffering messages and sending notifications to the reactor, that does not know or honour priority could lead to priority inversions.

- Several changes were made to utilize the new memory management mechanisms of Event Handlers in TAO. Previously, both the connection handlers and the transports had their own reference counting mechanism and independent lifetimes. The reference counting was inadequate since it was not originated at the Reactor and the independent lifetimes unnecessarily completed protocol specific transport code.

  The changes couple the lifetime of the connection handler with that of the transport and utilizes the reference count in the base ACE_Event_Handler class. This allowed us to remove several hacks throughout TAO code which were designed to prevent (or delay) crashes. Several extra checks and unnecessary locks were also removed.

  All of the following protocols were updated: DIOP, IIOP, SCIOP, SHMIOP, SSLIOP, UIOP, UIPMC.

- Support for the ORB methods create_value_tc, create_component_tc, create_event_tc, create_home_tc and create_recursive_tc added.

Back to TOC