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 $
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.
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.
Use GIOP 1.1 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.
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.
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.
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.
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
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.
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
Typecode::equal
dilemma: is it
structural or type equivalence? Or a mixin?
equivalent
method to check for structural
equivalence modulo aliases
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?
[STATUS] The code has been inspected and seems correct
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.
$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.
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: 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?
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
.
Need to support CORBA::Bounds to be compliant with 2.3 spec.
ORB: Support IIOP 1.2 in the ORB
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 sequenceSerializedData; 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
[STATUS] The new implementation of collocation has the
roots for this.
The ORB does not have an interface repository
Once the interface repository is in place we could add support for CORBA script
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.
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.
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.
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).
Support the thread pool reactor in the ORB.
[ASSIGNED TO:] Nanbor.
[DONE]
IDL Compiler: The TAO_IDL compiler does not handle the following code sequence properly:
// IDL interface Foo; typedef sequenceIt may be necessary to have a multi-pass code generator to solve this problem.FooSeq; interface Foo { // anything here };
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.
EC:The observer in the TAO_EC_Gateway
class is not properly deactivated.
[DONE]
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.
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.
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]
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]
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.
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.
EC: Debug interval computation in Linux (and NT?)
[DONE] There was a problem with the ACE_High_Res_Timer
initialization.
ORB: Support multiple calls to ORB_init(). This requires several changes:
-ORBid
option.
IDL Compiler:Support for unions with default cases
(implicit or explicit)
in the IDL compiler is incomplete.
[DONE] Andy implemented this features.
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.
Support GIOP 1.1 in the ORB (fragments)
[DONE] The ORB should be able to receive GIOP
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: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.