General TO-DO list for TAO

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/07/16 20:35:22 $ $Revision: 1.86 $


Work in progress

  1. 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.

  2. 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

  3. 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.


Pending Tasks

Performance optimizations

  1. Location forwarding should be strategized since some applications don't need this feature.

  2. Further optimize the outgoing memory allocation by adding support for message blocks allocated from a pool (the Message_Block class itself not the Data_Block or the buffer it contains).

  3. Optimize twoways by delaying memory allocation for the incoming data buffer, thus improving interleaving between the client and server (the client does something useful before starting to wait for the server). The client could also deallocate the outgoing buffers before waiting for the reply.

  4. The data blocks and their buffers could be allocated in a single operation, using the beginning of a buffer to contain the data block and the rest of it to contain the actual buffer

  5. For extremely low latency applications we could remove some fields from the IIOP protocol, for instance:


    [STATUS] Most of this optimizations were implemented, and can be enabled using the -ORBgioplite command line option.

  6. Once the memory for incoming data is taken from an allocator we can implement different approaches to manage that memory:

  7. 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.

  8. 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.

  9. 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.

  10. Use GIOP 1.1 fragments to minimize the buffer allocations: the buffer could be fixed size and we simply send fragments for each buffer.

  11. 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).

  12. 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.

  13. 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.

  14. 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.

  15. A new spec for Dynamic Any has been published and will probably be part of CORBA 2.4. There are a great many changes, leaving almost no area of the current implementation untouched.

New features and Bug fixes

  1. EC:Several tests must be added to the event channel testsuite, for example:

  2. 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.

  3. 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.

  4. ORB: Stress test the ORB in the presence of exceptions, verifying that no resources are leaked, all locks are released, etc.

    Note: small experiments indicate that everything is OK, and several tests raise exceptions without problems, but we need an intensive test of this features.

  5. 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.

  6. 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.

  7. The size of pre-allocated buffer for the outgoing CDR streams is defined at compilation time; but if we use an efficient enough allocator we could make its size configurable via the svc.conf file. In any case the *second* (and subsequent) buffers come out of the allocator, so their sizes could be configured in the already mentioned file.
    [NOTE] We have to be able to do this while minimizing the number of calls to ORB_Core_instance()

  8. IDL Compiler: The operation tables do not need to be statics, they could be created on creation of the first servant of that type.

  9. 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.

  10. IDL Compiler:Support for the fixed data type in the IDL compiler

  11. CDR stream support for wchar is flaky or at least untested.
    [STATUS] This is slowly beign implemented, and so are codeset translators inside the CDR streams.

  12. Add << and >> operators to the CORBA::Request class, to simplify DII invocations (this is an Orbix-sism). The IDL compiler has to generate them for the user defined types.

  13. ORB: Add a -ORBlogfile flag so we can set the ACE_ERROR and ACE_DEBUG output destination in all TAO applications

  14. EC: Call ORB_init() in the EC threads? [The dispatching threads for Boeing]

  15. EC: Build an EC example that uses all the cool features (multiple endpoints on each process, collocated EC and Scheduling Service, Naming, etc.)

  16. EC: Extend the Concurrency Service (or create a new one) that allow us to have global "barriers" to synchronize EC startup/shutdown.

  17. IDL Compiler: The IDL compiler could generate a static method to access the interface repository ID of a class.

  18. The current scheme for the orbsvcs leaves the user without control over collocation of servants, we need to move to a scheme similar to the one in $ACE_ROOT/netsvcs.
    [STATUS] The user can control collocation, but we need a dynamic way to do it (or an example) that exploits the Service Configurator. We also may need to split the library.
    [STATUS] David added a mechanism to compile only the services that we want.

  19. EC: Cleanup the IDL structures for subscriptions, publications, etc. (in the EC).
    [STATUS] Part of this was completed. The Header and Payload of the events are clearly distinguished, now we need to use only the Header in the Publication and Subscription definitions.

  20. Resolve the Typecode::equal dilemma: is it structural or type equivalence? Or a mixin?
    [STATUS] The correct interpretation seems to be:

  21. According to Vinoski and Henning the CORBA::Policy objects are also locality constrained. I could not find a references in the spec.

  22. Exercise the insertion and extraction operators for Any in the Param_Test, for example, provide a new -i dii_any_op testing mode.

  23. 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.

  24. IDL Compiler: Include a regression test to verify that octet is not a valid discriminator for unions

  25. IDL Compiler: CORBA 2.2 does not allow octets as constants, yet the IDL compiler does not complain about it.

  26. IDL Compiler: Verify that the typecode for unions use a octet with value 0 for the default discriminator.

  27. ORB: Is the client side in TAO handling a CloseConnection GIOP message properly?
    [STATUS] The code has been inspected and seems correct

  28. 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.

  29. $TAO_ROOT/orbsvcs/tests may require the same hierarchy changes that were done in $TAO_ROOT/tests.

  30. Can _duplicate() raise an exception? If so the mapping that we generate is not correct for platforms without native C++ exceptions.

  31. 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.

  32. 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.

  33. 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.

  34. IDL Compiler: We must also check that oneways do not contain any out or inout parameters.

  35. 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.

  36. 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.

  37. 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?

  38. 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:

  39. Need to support CORBA::Bounds to be compliant with 2.3 spec.


  40. ORB: Support IIOP 1.2 in the ORB

  41. 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.
    

  42. Add support for Smart Proxies to the ORB
    [STATUS] The new implementation of collocation has the roots for this.

  43. The ORB does not have an interface repository

  44. Once the interface repository is in place we could add support for CORBA script

  45. The current scheme for Typecode (keeping a CDR buffer with their representation) is broken; we should use classes for each variant of a TypeCode; but initialization would be complicated then.

  46. 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:

  47. 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.

  48. Server_Request objects in TAO are magical, the _duplicate() method returns 0 and release() does nothing. The problem starts because Server_Request is allocated from the stack (to speed up things), hence reference counting would be useless. Adding a clone() method will work better, but the Server_Request holds pointers to several positions in the CDR stream, we could clone the CDR stream, but a normal Server_Request does not own it.... In our opinion (Carlos and Irfan) we need not worry about this until we find a use case for it.


Completed Tasks

  1. 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.
    [DONE] Protocol attributes is deferred until the real-time spec is implemented.

  2. The current implementation of collocation is optimal for hard-real-time applications, but in some cases it may be desirable to follow the normal execution path yet minize costs for collocated calls. An example would include an application that activates the objects on demand. It would be interesting to have a half-collocated stub implementation, that will marshall the request and then invokes the normal path on the "server" side, but without crossing the kernel boundary. Ideally even the serialization could be minimized or avoided.
    [DONE] The ORB supports collocation through the POA.

  3. 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).

    [STATUS] The ORB can be compiled with support for CORBAlite (aka Minimum CORBA).

  4. Support the thread pool reactor in the ORB.
    [ASSIGNED TO:] Nanbor.
    [DONE]

  5. 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.
    [DONE] Andy has completed the implementation of recursive types.

  6. 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).
    [DONE] The ORB supports multiple-endpoints, mapping threads to endpoints is in another entry.

  7. EC:The observer in the TAO_EC_Gateway class is not properly deactivated.
    [DONE]

  8. 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.

  9. 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.
    [DONE] Bala implemented this feature.

  10. 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.
    [DONE]

  11. 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.
    [DONE]

  12. IDL Compiler: The methods on the server side must have a throw spec, check CORBA 2.2, 20.35
    [DONE] Andy implemented this as part of the support for native C++ exceptions.

  13. IDL Compiler: The IDL compiler should support #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.
    [DONE] Jeff (and others?) implemented this feature, the contents of the <orb.idl> file may need some work, but that is easy to fix.

  14. EC: Debug interval computation in Linux (and NT?)
    [DONE] There was a problem with the ACE_High_Res_Timer initialization.

  15. ORB: Support multiple calls to ORB_init(). This requires several changes:

  16. IDL Compiler:Support for unions with default cases (implicit or explicit) in the IDL compiler is incomplete.
    [DONE] Andy implemented this features.

  17. IDL Compiler: The IDL compiler front-end should be case insensitive, more precisely it should flag identifiers that only differ by case as a conflict and verify that all uses of an identifier have the same case.
    [DONE] Jeff implemented this feature, there is an option to disable it for backwards compatibility.

  18. Support GIOP 1.1 in the ORB (fragments)
    [DONE] The ORB should be able to receive GIOP

  19. Support IIOP 1.1 in the ORB

  20. Support native C++ exceptions. This entails the following subtasks:

    1. Create exceptions with the right dynamic type on the client side. For SII this should be simple: the stub give us a list of the possible user exceptions together with the factory methods to allocate an exception of each type; if the exception is not on that list we throw a 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.
      [STATUS] SII is working OK, we still need to complete the support for DII.
      [STATUS] The DII support was completed, but remains untested.

    2. Add the _raise() method to the exceptions.
      [DONE]

    3. On the server side: catch any CORBA exceptions thrown by the upcall, and then transform that into the proper Reply to the client side. In the case of another C++ exception should we do something?
      [DONE]

    4. On the client side, after creating the exception with the right dynamic type we must invoke _raise() on it.
      [DONE]

    5. Provide a TSS default value for the CORBA_Environment, all the methods in the ORB library should use this default.
      [DONE]

    6. IDL Compiler: The IDL compiler should be able to generate the alternative mapping, but with the TSS default for the env argument.
      [DONE]

    7. IDL Compiler: The IDL compiler should generate the standard mapping, without the environment argument.
      [DONE]

    8. 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

    9. We need to test the ORB for resource leaking in the presence of exceptions.

    10. We could write portable server side code with any of the mappings above if we use a macro for the env argument, but the results are ugly:
      // 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?


    [STATUS] The main task ahead is to generate the conforming mapping for the server side, i.e. remove the 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.

  21. EC:The new implementation of the EC does not send disconnect messages on shutdown, this has to be implemented.
    [DONE]

  22. 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.

  23. EC: The supplier filters could depend on the QoS data, as consumer filters do. We should provide a factory for them too.
    [DONE]

  24. 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]

  25. 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.

  26. 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.

  27. 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.

  28. The spec (CORBA 2.2, 20.17) defines accesor methods for the fields of a SystemException.
    [DONE]

  29. Remove the unneeded methods from CORBA::Object
    [STATUS] This task seems to be complete
    [DONE]

  30. Support the Sun bootstrapping mechanism for the Naming Service
    [STATUS] Replaced by the interoperable naming service bootstraping.

  31. Integrate the compiled marshalling approach.
    [STATUS] Andy has made great progress on this.
    [DONE]

  32. Verify the GPERF is working in all the relevant platforms.
    [STATUS] As far as we know it is working correctly.
    [DONE]

  33. Integrate active demux of operations?
    [STATUS] We use perfect hashing instead.

  34. 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.

  35. Add a corbafwd.h header file to eliminate the deep (and recursive) header dependencies in TAO.
    [DONE]

  36. In the collocated case the generated _narrow() method calls the _create_stub() method that allocates several temporary objects.
    [DONE]

  37. 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.

  38. 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.

  39. EC: The current architecture of the real-time Event Channel does not support some features, such as:

    We have completed a new design for the real-time event channel that will let us implement all this features (and others).
    [DONE] The new implementation is working, we have to add several strategies and stress test it, but the architecture seems sound.
    [ASSIGNED TO:] Carlos

  40. 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

  41. EC: Build a COS Event Channel on top of the RTEC Event Service.
    [DONE]
    [ASSIGNED TO:] Pradeep

  42. 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]

  43. 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:


    [ASSIGNED TO:] Carlos

  44. 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]

  45. 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.


    [DONE] Irfan fixed the ACE_OS::recvfrom() function.
  46. 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]

  47. EC: Improve configuration support in the EC, give an example of a single threaded EC, support different dispatching strategies, etc.
    [DONE] But there are a few bugs to remove.

  48. EC: Correlation in the EC has a bug [?]
    [DONE] Added a correlation test into the EC_Basic test, this does not mean that all bugs have been removed, but we don't know of any remaining bugs.

  49. The methods in CORBA::TypeCode should be const.


    [DONE]
  50. 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).


    [DONE]
  51. Add compiled marshalling
    [STATUS] Andy is working on this.
    [DONE] The compiled marshaling code works, we still have to fine tune it a bit.

  52. Implement the new DynAny types.
    [STATUS] Jeff is working on this.
    [DONE] More testing is needed, but the basics are there.

  53. 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]

  54. 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]

  55. 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]

  56. 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.

  57. 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.

  58. 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.

  59. 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.

  60. 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:

    the same hierarchy may be needed in $TAO_ROOT/orbsvcs.
    [DONE] Doug did this changes already, minor revisions many be necessary, and orbsvcs is still pending.

  61. Cleanup memory managment in some of the servers, for instance: Naming still believes that controlling the memory for a stub will control the servants, this is not true anymore.
    [DONE] Marina fixed the Naming Service, the other services are working OK also.

  62. 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.


    [DONE] Irfan removed the CORBA::B_TRUE and CORBA::B_FALSE constants and replaced them with the compliant 0 and 1
  63. Add an option to the IDL-compiler (e.g. -rp) meaning "generate relative include paths".
    [STATUS] Alex is working on this.
    [DONE]

  64. Add the <<= and >>= operators for CORBA::TypeCode
    [DONE] Jeff added the operators

  65. The IDL compiler should generate the code locally (not in the directory where the .idl resides) or at least give an option to do so
    [DONE] Alex completed this, he even added an option to select the output directory.

  66. Are nested upcalls in different concurrency models, like thread-per-connection working?
    [STATUS] Irfan reports that this works correctly with thread-per-connection
    [DONE] The NestedUpcall/Reactor test is giving the same results with either thread-per-connection or reactive strategies.

  67. Normalize the compiled marshalling interface: the IDL compiler is going to generate a different interface than the code I showed in the EC_Custom_Marshal example; we need to make all the code consistent so users have easy access to it.
    [DONE]

  68. Object references inside structures or sequences are not decoded properly, the problem starts because the interpreter expects a CORBA::Object_ptr, but the real type is a T_var; virtual inheritance adds the last ingredient to the poison.
    [STATUS] A possible solution is to use a T_manager_var that has two fields a Object_ptr and a T_ptr....
    [DONE] The solution was to use 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.

  69. Add options to the IDL compiler to set the suffixes.
    [DONE] Alex finished this.

  70. Support for 64bit longs in the IDL compiler
    [DONE] They were supported already, but we had to test them, I added a test to Param_Test.

  71. The do_static_call() and do_dynamic_call() methods should use an array of void* (in the first case static and generated by the IDL compiler); this will remove the problems with g++ and probably work faster.
    [DONE]

  72. The IDL compiler gets confused with paths in NT, this may be due to my changes to report errors correctly (coryan).
    [STATUS] Creating a Win32 workspace to try it.
    [DONE]

  73. The current implementation of octet sequences based on message blocks has a few problems, it cannot marshall chains of message blocks properly. Notice that complete support for chains of message blocks will complicate the sequence of octets implementation (like operator[]) and will make others either hard or expensive (like get_buffer ()).
    [STATUS] It seems like the best tradeoff would be to support the chain during marshalling, but disable or give no warranties for operator[] and get_buffer().
    [DONE]

  74. Debug Memory Pools in the EC there seem to be a problem when sending multiple events in a row (a memory leak, limit or corruption).
    [DONE]

  75. Add suspend and resume operations to the PushConsumerProxy and PushSupplierProxy interfaces, following the Notification Service spec.
    [DONE]

  76. Optimize connection lookup in the client side, using "hints" from the previous lookup, or keeping smaller sets on each IIOP profile or a combination of both.
    [STATUS] Irfan is working on this.
    [DONE]

  77. Optimize the outgoing CDR streams by using TSS memory pools for both the data blocks and the buffers.
    [DONE] But we may consider strategizing the kind of allocator we use (like using a free list instead of a generic ACE_Malloc).

  78. Optimize Octet Sequences.
    [DONE]

  79. Obtain results for the EC_Multiple test.

  80. Debug EC_Multiple.

  81. Your next assignment: Regenerate all methods in _tao_collocated to avoid "inherit via dominance" warnings.
    [STATUS] The IDL compiler was modified to generate a suitable #pragma that removes the warning, it reenables the warning when leaving the file

  82. Remove the SOLARIS2 macro from the TAO_IDL compilation.
    [DONE]

  83. Remove the preemption_prio message from Scheduling_Service.

  84. The ORB core should be able to choose the right port for us (in other words -ORBport 0) should work.
    [DONE]

  85. Client side optimization for Octet Sequences.
    [DONE]

  86. Minimize memory allocation in TAO
    [STATUS] Down to 3 on the client side and 4 on the server side.
    [STATUS] For oneways it is down to 0 (for the common case) on the client side and 2 on the server side. For twoways it is 2 on both sides.

  87. Automate subscription and publication list generation in the EC_Gateway. [VERY important for Boeing]
    [STATUS] Completed and debugged, but the EC is still buggy.

  88. Debug EC shutdown and startup.... [Specially startup for Boeign, but shutdown is important for Purify and Quantify]
    [STATUS] Shutdown is clean and startup of threads can be controlled by the user.

  89. Support a chain of Message Blocks in Output CDRs and use writev() to write them.
    [DONE]

  90. Memory managment in the demarshalling engine, it is not clear that the current scheme works in all cases (like sequences of unions of anys). We also need to fix sequences of object references: how does the demarshalling engine learn about the dynamic type of the objects? Closely related to this is the problem of memory alignment for different architectures, we need to develop strategies for each one (they should only be a few) and choose the right one.
    [STATUS] This seems to be working for most of the cases, the main idea is to delay demarshalling until enough information is available, for instance, when decoding an Any just a reference to the CDR stream is stored, decoding actually happens when the user invokes >>= on the any (at that point all the info is there).

  91. Add a new Profile type that includes the QoS info and using for end-to-end QoS preservation. [DEPRECATED] The IIOP 1.1 Profiles can handle that.

  92. Show an example of the sequence<octet> and CDR streams.
    [DONE] But the example could also include the marshalling of plain C++ types.
    [DONE too]

  93. Test anys in the EC.
    [DONE] Michael reported that they work OK on NT.

  94. UDP for event channel and Multicast support in the EC.
    [STATUS] Manual configuration using Suppliers and Consumers is possible, automation is under research.

  95. Unbind the EC and scheduling service from the Naming Service.
    [DONE] For the Event_Service and the examples.

  96. Optimize oneways by not allocating the memory for the return buffers.
    [DONE] Added different Invocation classes for each case.

  97. Fix the _non_existent call.
    [DONE] The client side semantics match the new clarifications of the C++ RTF, the server side is implemented by the IDL compiler, though t could be a good idea to put that in the POA.

  98. Simplify EC configuration, a Factory class must provide the Dispatching, Supplier, Correlation and any other Modules that are required. This is the right spot to add trivial Dispatching or Correlation Modules and to dynamically load and configure the EC.
    [DONE] A Factory class is used to create the modules, only the default factory is implemented so far.

  99. Fix the ACE_Thread_Condition madness.
    [DONE] We changed ACE so ACE_SYNCH_CONDITION expands to ACE_Condition_Thread_Mutex

  100. Reference counting should have locks, but we should remove all the QueryInterface madness to make that work. The policy for references in multiple threads is: the reference count must be >2 if that happens.
    [STATUS] The QueryInterface method (all the COM stuff for that matter) was removed...
    [DONE]

  101. Reference counting for Typecodes is completely broken.
    [DONE]

  102. Under g++(2.7.2) the use of multiple inheritance in IDL triggers some compiler bug, if the IDL explictly generated the copy constructor for the skeletons (the POA_ classes) the problem would go away.
    [DONE] Fixed, Seth is testing the fixes and will commit them soon (Tue Jul 21 14:24:56 CDT 1998)

  103. The octet sequence optimization causes problems when Anys get into the game.
    [DONE] Seth reported that the problem was not real.

  104. The DEEP_FREE method is also broken, sometimes we need to release the top-level memory, sometimes not.
    [DONE] We always release the memory in the Any, it was failing due to weird interactions between the Environment containing an exception and the Any that also did.

  105. Improve error messages in the IDL compiler.
    [DONE] At least the filename is correct now.

  106. Support for arrays in the IDL compiler is incomplete, specially anonymous arrays.
    [DONE] According to Andy this is properly supported by the IDL compiler now.

  107. Prepare the 0.2 release:

    1. Execute all the tests in $TAO_ROOT/tests
    2. Run Param_Test (SII) and record what fails and what works.
    3. Run Param_test (DII) and record what fails and what works.
    4. Run Param_Test across Endian Borders.

    [DONE] At last!

  108. Move this list to the release notes.


Back to the TAO documentation index