This document presents our TO-DO list for TAO. Currently, the list is not very well organized or prioritized. It started as a personal TODO list for Carlos, so it is biased towards the Event Service and related components. As more people get involved it will become more organized.
Last Updated: $Date: 1999/05/19 20:29:35 $ $Revision: 1.81 $
Implement an Implementation Repository for TAO.
	  
[ASSIGNED TO:] Darrell.
	
Support the thread pool reactor in the ORB.
	  
[ASSIGNED TO:] Nanbor.
	
Implement a nice example of the COS Event Channel,
          showing how it can provide filtering when combined with the
          real-time Event Channel.
          
[ASSIGNED TO:] Pradeep
        
EC: Complete the implementation of the new EC, specially generate the strategies and changes required to support hard real-time behavior.
The new EC does not update the dependencies in
	  the scheduling service. We should be able to strategize this 
	  by the appropiate use of a Filter_Builder and
	  decorators for the regular filters.
          
[ASSIGNED TO:] Carlos
	  
[STATUS] All the pieces are in place, but I have to
	  continue debugging it.
        
Implement the Interoperable Naming Service spec,
	  specially the new standard features to bootstrap the initial 
	  object references in the ORB.
          
[ASSIGNED TO:] Vishal
	  
[STATUS] He is making good progress, near completion by
	  now.
        
Improve the connection recycling strategies, for
	  instance,
	  several strategies are possible: limit the maximum number of
	  open sockets, probably with both HWM and LWM bounds,
	  with different policies to choose the socket to close (LFU,
	  MRU?);
	  or maybe be more aggresive and recycle a socket once
	  all the object references pointing to a server are closed.
	  The later approach could be easily implemented if each
	  IIOP_Object held a reference to the set of sockets opened to
	  a certain TCP/IP address.
          
[ASSIGNED TO:] Kirthika
	
If the connection to the server cannot be established the
	  right exception is TRANSIENT, not
	  COMM_FAILURE; this and other exception
	  inconsistencies have to be checked
	  
[STATUS] Most of this work has been completed, there are 
	  a few i's to dot and t's to cross, for example:
	  what is the right exception to raise when a
	  write() fails? The answer is
	  none, we must transparently retry the current profile, not
	  the next one.
          
[ASSIGNED TO:] Carlos
	  
[STATUS] The path on the client side seems clean
	  now. The server side is still under revision.
	
Add support for timeouts and protocol attributes to the
	  ORB.
          
[ASSIGNED TO:] Carlos
	  
[STATUS] Support for the Policy objects is present, but
	  we haven't implemented any of the Policy objects and, of
	  course, we don't use them.
	
Location forwarding should be strategized since some applications don't need this feature.
For extremely low latency applications we could remove some fields from the IIOP protocol, for instance:
Principal, the services
	    context list, the versions can also be removed
	  -ORBgioplite command
	line option.
      
      Once the memory for incoming data is taken from an allocator we can implement different approaches to manage that memory:
Optimize marshaling for TypeCode, by not
	  including the optional fields on the wire;
	  this fields are useful (in some cases), so they should be
	  present for the "on memory" representation.
	
In some cases it is possible to marshal a complete structure in a single operation to allow this the structure must have fixed size (in the CDR spec sense) and its memory layout must match the CDR layout.
If all the arguments to an operation are fixed size then the header can be sent before the rest of the data, if the data is big enoug this can represent a performance improvement (because we increase overlapping between client and server); further if the arguments also have the proper layout they can be sent without copying to a temporary buffer.
If the arguments are not fixed size the header could be sent before, but two passes over the data will be required.
One GIOP 1.1 is implemented we could use fragments to minimize the buffer allocations: the buffer could be fixed size and we simply send fragments for each buffer.
Demarshaling and managment of Anys could be optimized, they esentially keep a copy of the CDR stream, but they could just keep a reference (and increase the reference count).
Some uses of DSI can optimized also, for instance, if the application is simply going to forward the request to another object there is no need to parse the arguments in the CDR stream and decompose them in the arguments, a single *big* CDR stream can be kept.
The CDR streaming classes compute the alignment on each operation, but they could remember the alingment from the previous insertion or extraction operation; saving a few cycles but spending a little more memory.
Some applications cannot afford compiled marshaling for
	  all the stubs and skeletons,
	  the generated code size would be too big.
	  Yet some operations could be critical and require code as
	  efficient as possible;
	  a #pragma can be added to give users
          fine-grained control over code generation.
	
EC:The Priority_Dispatching strategy
	  is incomplete.
	  
[STATUS] The latest round of changes completed the
	  implementation, but more testing is required before dropping 
	  this task
        
EC:Implement a dispatching strategy that uses the current thread priority or ID to dispatch the event. This will let us use multiple queues at different priorities but without any scheduling service.
EC:Implement a null filter for consumers that correctly matches the events, this can be used to do all the filtering on the suppliers for applications that do not require correlation.
EC:Several tests must be added to the event channel testsuite, for example:
EC_Throughtput).
	  Event_Latency)
	  EC:Should we provide strategies to enforce the QoS publications and subscriptions? This could require collaborations with the scheduling service and possibly it is only useful for debugging real-time applications, but it certainly seems interesting.
EC: Optimize the updates to the SupplierFiltering
	  module, specially when it is a singleton: currently it
	  receives a connected call for each supplier,
	  event though one would be enough.
        
EC: We need some strategy in the EC to periodically flush out mibehaving suppliers and consumers. Examples of misbehavior include: suppliers flooding the EC; consumers or suppliers that are destroyed, but were not disconnected; consumers that are not accepting events (risking a dead-lock); etc.
EC:The observer in the TAO_EC_Gateway 
	  class is not properly deactivated.
        
EC: Sometimes the Event Channel dead-locks during
          shutdown. According to Ulf Jährig
	  <jaehrig@desys.com>, an easy way to reproduce the
	  problem is to run the EC_Throughput test under windows NT.
	  
[STATUS] The test in question works perfectly on NT; it
	  looks like a race condition. Apparently this is only a
	  problem with the old EC.
        
IDL Compiler: Support for the version 
	  pragma, this also requires some changes in the
	  _is_a() implementation.
	
Support native C++ exceptions. This entails the following subtasks:
CORBA::UNKNOWN.
	      For DII we have to throw a
	      CORBA::UnknownUserException;
	      the user will receive the real exception inside an
	      Any then and she will have to extract it
	      either using the >>= operator or using the
	      forthcoming DynAny.
	    System exceptions are even easier, we always know how
	      to create them.
	    Reply to the client side.
	    In the case of another C++ exception should we do
	    something?
	    _raise() on it.
	    In general we will need to complete and debug the
	      TAO_TRY macros;
	      they have limitations when dealing with the
	      alternative mapping, but are very useful.
	      
[STATUS] This seems to be OK now, the code seems to
	      compile and work correctly now.
	      
[STATUS] We need a new macro (TAO_TRY_THROW) to use
	      inside the TAO_TRY blocks, because TAO_THROW will not go
	      into the TAO_CATCH blocks, even if the exceptions match.
	      
[STATUS] Nanbor implemented a much better set of
	      macros, that can be used with other ORBs, it is
	      implemented in $ACE_ROOT/ace/CORBA_macros.h
	    
// IDL
interface Foo {
  void bar (in long x);
};
// C++ 
class Foo {
  void bar (CORBA::Long x TAO_ENV_ARG)
               TAO_THROW_SPEC ((CORBA::SystemException));
};
	    
	    note the missing comma before the TAO_ENV_ARG parameter.
            A different alternative is to generate both functions, and make the default implementation just invoke the other:
// IDL
interface Foo {
  void bar (in long x);
};
// C++ 
class POA_Foo {
  void bar (CORBA::Long x, CORBA::Environment& env)
               TAO_THROW_SPEC ((CORBA::SystemException))
  {
    this->bar (x);
  }
  void bar (CORBA::Long x)
               TAO_THROW_SPEC ((CORBA::SystemException)) = 0;
};
	    
            The problem is: which alternative should be the pure
            virtual function? Which one is overriden by the user?
	  CORBA::Environment argument and generate the
	throw specs.
	We need to wait for the compiled marshaling support to
	implement this feature, otherwise the number of conflicts,
	visitors and factories will grow without limit.
      
      EC: Automate EC multicast group usage. This probably
	  requires some kind of server that mantains the relation
	  between event type/source and the mcast groups.
	  
[STATUS] The multicast map server was defined, an
	  example implementation that hardcodes the port, and casts
	  the event type into the mcast address was implemented.
	  
[STATUS] An advanced example that uses multiple mcast
	  groups per process was developed; this example would be used
	  To test the required features for general mcast support.
	  
[STATUS] The example is able to automatically join and
	  leave multicast groups, as the consumer set on a local EC
	  changes.
	  The test has been constructed to minimize resources, it only
	  uses one socket for outgoing multicast messages;
	  currently it uses only one socket for each local group of
	  multicast UDP addresses sharing the same port;
	  eventually more sockets may be needed,
	  as sockets have limits on the number of multicast groups
	  they can join.
	
EC: The TAO_EC_Gateway_IIOP can be
	  required to subscribe for events by source, but the source
	  can be local instead of remote.
	  This is not a problem since the Event Channel supports
	  multiple supplier IDs,
	  but we could check the local publications and remove those
	  events from the Gateway publication and subscription list.
	  
[STATUS] The task is a second order optimization and has 
	  very low priority.
	
It seems that some memory is leaked from the ORB cached connector; but Purify gets confused by the fact that TAO dynamically loads libTAO, so it could be just a bogus report.
fixed data
        type in the IDL compiler 
      wchar is flaky or at
        least untested.
      CORBA::Request class, to simplify DII invocations
	(this is an Orbix-sism).
	The IDL compiler has to generate them for the user defined
	types.
      ORB: Add a -ORBlogfile flag so we can set the ACE_ERROR and ACE_DEBUG output destination in all TAO applications
ORB: Support multiple calls to ORB_init(). This requires several changes:
-ORBid option.
	  ORB: Support multiple endpoints in the ORB. Some interesting concurrency models (such as thread-per-endpoint or thread-pool-per-endpoint) require that we give an explicit name to each endpoint, and use policies to match the thread with the endpoints it will serve (and share).
#include "orb.idl" properly.
	IMHO it should not
	add any #include to the generated code and the
	orb.idl file should contain all the declarations,
	except for the pseudo objects that are should be hardcoded
	into the compiler.
      Typecode::equal dilemma: is it
        structural or type equivalence? Or a mixin?
	equivalent method to check for structural
	    equivalence modulo aliases
	  IDL Compiler: The methods on the server side must have a throw spec, check CORBA 2.2, 20.35
According to Vinoski and Henning the
	  CORBA::Policy objects are also locality
	  constrained.
	  I could not find a references in the spec.
Exercise the insertion and extraction operators for
	  Any in the Param_Test,
	  for example, provide a new -i dii_any_op
	  testing mode.
	
Test Any with variable sized types, such as
	  structures that contain a string inside.
	  Jeff reports that there is a
	  problem when destroying Anys initialized with this types,
	  even if the IDL compiler generated <<= operator is
	  used.
	  
[STATUS] Many of the services do this kind of thing, for 
	  example the Trading service passes all kinds of data in
	  Anys.  The current version seems to be working , so this is
	  not a high priority task.
	
IDL Compiler: Include a regression test to verify
	  that octet is not a valid discriminator
	  for unions
	
IDL Compiler: CORBA 2.2 does not allow
          octets as
	  constants, yet the IDL compiler does not complain about it.
	
IDL Compiler: Verify that the typecode for
	  unions use a octet with value 0
	  for the default discriminator.
	
ORB:
	  Is the client side in TAO handling a
	  CloseConnection GIOP message properly?
	
IDL Compiler: In some platforms it may be necessary to add an extra value to an enum to force it to be 32-bits wide.
POA: The SINGLE_THREAD_MODEL for the
	  POA requires that at most one concurrent call is invoked on
	  each servant in that POA.
	  
[STATUS] Irfan is working on it as part of the POA
	  concurrency fixes.
	
$TAO_ROOT/orbsvcs/tests may require the same
	  hierarchy changes that were done in
	  $TAO_ROOT/tests.
	
Can _duplicate() raise an exception?
	  If so the mapping that we generate is not correct for
	  platforms without native C++ exceptions.
	
ORB:
	  The implementation for the leader-follower
	  model on the client side has bug:
	  it will add the current thread to the follower list every
	  time it returns from waiting in the condition variable,
	  assuming that it was signaled and removed every time.
	  
[STATUS] This is not a big problem because only a
	  warning is printed out.
	
ORB:
	  By default TAO disables Nagle's algorithm, this should be
	  an optional feature, otherwise TAO will perform poorly over
	  WANs.
	  
[STATUS] An alternative: this could be fixed as part of
	  the real-time spec that introduces transport specific
	  policies.
	
Check that system calls like recv() and
          send() are restarted if a signal is received by
          the process while they are executing.
	  
[STATUS] In general this is done by ACE, but there have
	  been bug reports related to this.
        
IDL Compiler: The CORBA 2.3 spec clarifies the
	  scope of a
          #pragma prefix:
          the prefix is supposed to get cleared after each
          #include,
          also the statement
#pragma prefix ""should clear the prefix.
IDL Compiler: GPERF is generating a function for each binary search table; a generic function could be used, or at least we should add an option to gperf to it receives that generic function as an argument.
IDL Compiler: The TAO_IDL compiler does not handle the following code sequence properly:
    // IDL
    interface Foo;
    typedef sequence FooSeq;
    interface Foo {
      // anything here
    }; 
 
        It may be necessary to have a multi-pass code generator to
        solve this problem.
        
      IDL Compiler: We must also check that oneways do
          not contain any out or inout
          parameters.
        
Currently we use blocking writes for the request, we need
          to change this so we use the Reactor to send the data
          instead of blocking directly on the writev call.
        
ORB: When handling a forward request we may get forwarded to a collocated object. The typical scenario is a server that register with the Implementation Repository: if it creates an object reference to a local object the object reference will be pointing to the ImplRepo and potentially none of its profiles will match the local ones. Trying to contact the ImplRepo will result in a LOCATION_FORWARD exceptions (and/or a LocateReply) pointing to the local endpoints, but now we should use collocation.
ImplRepo: How do the ImplRepo and pluggable protocols interact? What if the ImplRepo is using a protocol that is not implemented in the server? Or vice-versa?
We need support for the timeout policies specified in CORBAmessaging. The timeouts can control connection and total request time.
ORB: Decouple the ORB from interpretive marshaling. This style of marshaling will not be required for many applications, and it increases the footprint significantly (around 10%). The tasks required are:
_tao_destroy method, that would delete an
	    object through a void*.
	    Such an operation will allow us to implement
	    Any without the deep_free
	    operation.
	  append to stop the recursion once
	    the source and destination CDR streams have the same
	    alignment.
	  skip operation is only
	    used in the Any support.
	    It may be possible to agressively reduce the footprint by
	    removing both skip and Any.
	  The TAO_Object_Manager class needs an
	  assigment operator from T_var.
	  Either change the class to have two arguments or 
	  use the T::_var_type trait.
	  We also have to change the class generated by the IDL
	  compiler.
	  Similar changes maybe required for the
	  TAO_String_Manager and the
	  TAO_Object_Field classes.
	
Provide mechanisms to marshal arguments into a CDR stream, Jon Biggar contributed his proposal to the CORBA 2.3 RTF:
Issue 991: Operations to add to CORBA::ORB pseudo-object
Proposal:
[Note I have expanded the SerializedEncoding IDL type to include version
information, since we now have 3 versions of CDR!]
The following operations should be added to the CORBA::ORB
pseudo-object:
module CORBA {
        interface ORB {
                ...
                typedef sequence SerializedData;
                typedef unsigned long   SerializedFormat;
                const SerializedFormat ENCODING_CDR = 0;
                struct SerializedEncoding {
                    SerializedFormat    format;
                    octet               major_version;
                    octet               minor_version;
                };
                SerializedData serialize(in Any data,
                    in SerializedEncoding how);
                Any unserialize(in SerializedData data,
                    in SerializedEncoding how);
                SerializedData serialize_value(in Any data,
                    in SerializedEncoding how);
                Any unserialize_value(in SerializedData data,
                    in SerializedEncoding how,
                    in TypeCode tc);
                ...
        };
};
These operations provide a standard mechanism for serializing and
unserializing the data in an any, along with hooks to support new
encoding formats as they are needed.  The type SerializedEncoding
indicates the encoding mechanism to use to serialize and unserialize the
data.  The format field specifies what encoding rules to use when
serializing the data, and the major_version and minor_version indicate
what version of the encoding rules to use.
The serialize and unserialize encode the TypeCode along with the value
so that the serialized data is self contained.  The serialize_value and
unserialize_value version encodes the value without the TypeCode to save
space, but a TypeCode must be supplied to unserialize the data.
Since the serialized data may contain no indication of machine dependent
issues such as byte order, the serialized data can only be guaranteed to
correctly be unserialized on the same ORB.  The IDL any type should be
used to exchange information between ORBs.
Data encoded using the ENCODING_CDR format will be encoded using CDR
encapsulation format.
 
        
      Add support for Smart Proxies to the ORB
The ORB should support server side and client side interceptors
The ORB does not have an interface repository
Once the interface repository is in place we could add support for CORBA script
The CORBAlite RFP is very interesting IMHO we just need to remove features from TAO to make it a CORBAlite implementation. The problem is how to keep the full blown CORBA implementation also, this is an idea: Write the TAOlite version of a class (example TypeCode):
	class TAO_CORBAlite_TypeCode {
	// Just the CORBAlite methods are implemented.
	};
	
	Derive the full blown implementation:
	  class TAO_CORBA_TypeCode : public TAO_CORBAlite_TypeCode {
          // Declare all the other methods.
	  };
	
	create two namespaces:
	  // in tao/CORBAlite.h
	  class CORBA {
	    tyedef TAO_CORBAlite_TypeCode TypeCode;
	  };
	
	  // in tao/CORBAfull.h
	  class CORBA {
	    typedef TAO_CORBAfull_TypeCode TypeCode;
	  };
	
	then (at compile time) the users chooses between the CORBAlite or CORBAfull implementations:
// In $TAO_ROOT/tao/corba.h #if USERS_WANTS_FAT_FREE_CORBA #include "tao/CORBAlite.h" #else #include "tao/CORBAfull.h" #endif
We need to consider how to support even smaller profiles that
	    the CORBAlite RFP, like removing Any or
	    fixed<> support.
	    We also need to come out with a scheme to support
	    interpretive marshalling in the CORBAlite framework (where
	    TypeCodes don't have enough methods as to traverse them).
      
Consider decompositions of the ORB that would allow dynamically linked plug-ins, for example it should be easy to dynamically load a pluggable protocol. Other decompositions are harder, but still worthwhile looking at:
IDL Compiler: Currently the IDL compiler creates an operation table that includes all the base classes operations; this permits the generation of efficient code that does not rely in dynamic_cast or the _downcast() method for Servants (which compare strings, hence it is slow). It could be interesting to implement the alternative approach were the class only looks its own operations and then tries the parent. This will reduce code size, but will probably decrease performance.
EC:The new implementation of the EC does not send
	  disconnect messages on shutdown, this has to be 
	  implemented.
	  
[DONE]
        
EC: Use the Service_Configurator to dynamically load
	  the EC Module_Factory thus making it really configurable.
	  The same feature is needed for the new
	  EC_Factory class.
	  
[STATUS] Notice that this is fairly easy to implement,
	  there doesn't seem to be much demand for it.
	  
[DONE] In the new EC it is possible to load the
	  strategy factory.
	
EC: The supplier filters could depend on the QoS
	  data, as consumer filters do. We should provide a factory
	  for them too.
	  
[DONE]
        
EC: We need to provide simple operations to update
	  the subscriptions of a consumer, as well as the publications 
	  of a supplier, the current scheme (disconnecting and
	  connecting again) is inefficient.
          
[ASSIGNED TO:] Carlos
	  
[DONE]
        
IDL Compiler: Tom Ziomek
          <tomz@cc.comm.mot.com> reports that the IDL
          compiler does not verify that oneway operations
          cannot include a raise expression.
	  
[DONE] Andy fixed this.
        
The _duplicate() and _narrow()
	  functions can throw exceptions, yet our mapping does not
	  contain an CORBA::Environment argument.
	  A similar problem ocurs with
	  ORB::resolve_initial_references, the ORB can
	  throw the InvalidName exception.
	  
[DONE] But the status of _duplicate()
	  remains, I added an entry for it.
	
The spec requires that strings as fields of structures be
	  initialized to the empty (not the null) string.
	  
[DONE] Andy this this is the String_Manager 
	  class.
	
The spec (CORBA 2.2, 20.17) defines accesor methods for the
	  fields of a SystemException.
	  
[DONE]
	
Remove the unneeded methods from CORBA::Object
	  
[STATUS] This task seems to be complete
	  
[DONE]
	
Support the Sun bootstrapping mechanism for the Naming
	  Service
	  
[STATUS] Replaced by the interoperable naming service
	  bootstraping.
	
Integrate the compiled marshalling approach.
	  
[STATUS] Andy has made great progress on this.
	  
[DONE]
	
Verify the GPERF is working in all the relevant
	  platforms.
	  
[STATUS] As far as we know it is working correctly.
	  
[DONE]
	
Integrate active demux of operations?
	  
[STATUS] We use perfect hashing instead.
	
Several helper structs for Any have to be
	  added, mainly: to_object, to_wchar,
	  to_wstring and their from_
	  
[DONE] Jeff added them to the Any class, later they were 
	  moved to the CDR streaming classes because they are needed
	  there too.
	
Add a corbafwd.h header file to eliminate
	  the deep (and recursive) header dependencies in TAO.
	  
[DONE]
	
In the collocated case the generated
          _narrow() method calls the
          _create_stub() method that allocates several
          temporary objects.
	  
[DONE]
        
For various projects, we need to produce a
          minimal-footprint TAO ORB.  One thing we could probably do
          very easily would be to provide an #ifdef that will
          conditionally omit the servant manager, POA manager, and
          adapter activator features from TAO, along with all the
          demuxing features that aren't active demuxing or perfect
          hashing.
	  
[DONE] Irfan implemented exactly this. We still have
	  room for more footprint size optimizations, but they are
	  second order things.
        
Add support for multiple Profiles in the ORB (completing
          the IIOP 1.0 support)
          
[ASSIGNED TO:] Fred
	  
[DONE] Fred added support for multiple profiles as part
	  of the pluggable protocols effort.
        
EC: The current architecture of the real-time Event Channel does not support some features, such as:
EC: Some applications are both suppliers and consumers of events, they may be interested in all the events of type T unless the event is generated by them.
EC: Can we factor out the scheduling service from the EC?
EC: The reactive event channel can eliminate
                data copies because the data does not need to survive
		after the push() call.
              
EC: Many applications require to intercept the EC event processing, for example to keep track of the number of events received and sent. This requires strategized factories for many (if not all) of the Event Channel internal servants.
EC: Some applications require ad-hoc filters, such as "this events must arrive in sequence", or "wait for all this events and then send this other event".
EC: For some applications it is insteresting to activate the EC servants (such as the ConsumerProxys) in different POAs
IDL Compiler:The IDL compiler could generate files
          with empty 
	  implementation classes, just to make the life of implementors
	  a bit easier.
	  
[DONE]
	  
[ASSIGNED TO:] Yamuna
        
EC: Build a COS Event Channel on top of the RTEC
	Event Service.
	  
[DONE]
	  
[ASSIGNED TO:] Pradeep
        
EC:Implement fragmentation and reassembly of UDP
          messages. This is important for an effective implementation
          of the multicast version of the EC. The classes affected
          include UDP_Receiver and UDP_Sender.
          
[DONE]
        
EC: The Event Channel must be profiled, quantified, etc. Now that we have a single threaded event channel this task is much easier, the points to investigate are:
The TypeCode internal (private) state needs locking, double
          checked locking is needed to avoid excessive overhead, there
          is potential for memory leaks if this locking is not used.
          
[DONE]
        
EC:The UDP_Receiver class has some
          problems on Win32 platforms because a
          recvfrom() call fails if the buffer is to small
          for the datagram, even if the MSG_PEEK flag is
          used.  We may need to modify the
          ACE_OS::recvfrom() call to match the unix
          semantics.
        
ACE_OS::recvfrom()
        function.
      EC: When shuting down a reactive Event Channel the
          timeouts for the EC have to be cancelled.
          It would seem like the proper way to do that is to do it in
          the shutdown() method of the
          Timer_Module.
          
[DONE]
        
The methods in CORBA::TypeCode should be
	  const.
	
Add the CORBA::TypeCode::_tc_Bounds and the
	  CORBA::TypeCode::_tc_BadKind type codes.
	  Currently they are in the wrong namespace (just
	  CORBA::_tc_Bounds).
	
Add compiled marshalling
	  
[STATUS] Andy is working on this.
	  
[DONE] The compiled marshaling code works, we still have
	  to fine tune it a bit.
	
Implement the new DynAny types.
	  
[STATUS] Jeff is working on this.
	  
[DONE] More testing is needed, but the basics are
	  there.
	
EC:The TAO_EC_Gateway_IIOP class
	  receives events from a "remote" EC and pushes them on the
	  local EC.
	  The subscription and publication list for the Gateway are
	  the disjunction of the local EC consumer subscriptions.
	  Unfortunately this can result in multiple supplier_IDs for
	  the Gateway, the current implementation is not prepared to
	  handle this.
	  The Gateway must keep a list of suppliers, each one with a
	  different supplier id,
	  when it receives a remote event it should push the event
	  only to the right supplier.
	  It must also keep another supplier used for the events that
	  are of interest by their event type, regardless of their
	  supplier ID.
	  
[DONE]
	
EC:The Event Channel must be able to accept more
	  than one supplier with a given supplier ID, or at least we
	  should be able to configure the EC to work in such a mode.
	  This is required for some applications that treat the
	  supplier ID as a "supplier type".
	  
[DONE]
	
EC:If a Supplier disconnects while it has
	  consumers registered for it's Supplier_ID,
	  the consumers are not connected again even if the supplier
	  reconnects.
	  
[DONE]
	
Further optimize memory allocation by using a memory pool
	  for the incoming CDR stream.
	  
[DONE] The pool is configurable for the users that may
	  want to steal the CDR buffer.
	
The nested upcall support must be strategized,
	  some applications don't need this feature,
	  other applications are single threaded or use an
	  ORB-per-thread concurrency policy,
	  so using a full-blown leader follower in all cases can
	  result in a significant slow down.
	  It seems like the right way to
	  strategize this by changing the Client_Connection_Handlers.
	  
[DONE] Irfan and Carlos are finished this task.
	
Use active demuxing in the POA to locate servants in
          constant time, as well as active demuxing
          in the skeletons to locate operations in constant time.
	  
[DONE] Irfan finished this task.
	
Sometimes the ORB picks up the wrong name on multi-homed
	  hosts,
	  the ACE_INET_Addr class uses
	  gethostbyaddr_r to convert from the address into
	  a hostname, but it only uses the first alias.
	  
[DONE] The current implementation tries to use the
	  alias that more closely matches the address of the given
	  host.
	
Many of the test programs in the
	  $TAO_ROOT/tests hierarchy are actually sample
	  programs or performance tests.
	
We need to re-organize this hierarchy, following the ACE scheme:
$TAO_ROOT/orbsvcs.
	The mapping for the CORBA boolean type does
	  not require the CORBA::TRUE constant,
	  but it never mentions the CORBA::B_TRUE constant
	  either; in fact it recommends the usage of the literals
	  0 and 1.
	  We should move to use the CORBA::TRUE style,
	  because other ORBs offer the same feature,
	  but only use the literals,
	  to show the "Right Way"[tm] of doing CORBA things.
	
CORBA::B_TRUE and
	CORBA::B_FALSE constants and replaced them with
	the compliant 0 and 1
      Add an option to the IDL-compiler (e.g. -rp) meaning
	  "generate relative include paths".
	  
[STATUS] Alex is working on this.
	  
[DONE]
	
Add the <<= and >>= operators for
	  CORBA::TypeCode
	  
[DONE] Jeff added the operators
thread-per-connection
	NestedUpcall/Reactor test is
	giving the same results with either
	thread-per-connection or reactive
	strategies.
      TAO_Object_Field_T<T>, that
	  behaves like the _var classes, but extends them to provide
	  virtual methods to _upcast() and
	  _downcast() to and from
	  CORBA_Object_ptr.
	  Similar methods were added to sequences of objects.
      void*
	(in the first case static and generated by the IDL compiler);
	this will remove the problems with g++ and probably work
	faster.
	#pragma that removes the warning, it reenables
	the warning when leaving the file
      sequence<octet> and CDR streams.
	  
Back to the TAO documentation index.