diff options
175 files changed, 20215 insertions, 2482 deletions
diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a index 2c37693d3e4..c297d4327d1 100644 --- a/TAO/ChangeLogs/ChangeLog-02a +++ b/TAO/ChangeLogs/ChangeLog-02a @@ -1,3 +1,1028 @@ +Tue Apr 24 00:21:54 2001 Carlos O'Ryan <coryan@uci.edu> + + * Merged in all the changes required to fix [BUGID:132] + + Mon Apr 23 22:05:56 2001 Carlos O'Ryan <coryan@uci.edu> + + * examples/PluggableUDP/DIOP/DIOP_Transport.cpp: + * examples/PluggableUDP/DIOP/DIOP_Transport.h: + * examples/PluggableUDP/DIOP/DIOP_Connection_Handler.cpp: + Update to match the new Transport classes. + + * tao/IIOP_Transport.cpp: + Cosmetic fixes + + Mon Apr 23 21:10:40 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/AMI_Buffering/client.cpp: + * tests/Big_Oneways/Coordinator.cpp: + * tests/Big_Twoways/Coordinator.cpp: + Fixed ACE_CHECK/ACE_TRY_CHECK mismatches. + + Mon Apr 23 16:40:07 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.h: + * tao/Transport.cpp: + * tao/Reactive_Flushing_Strategy.cpp: + The schedule_output() and cancel_output() methods are invoked + while the handle_mutex_ is held, so there is no need to grab it + again. + The methods are renamed schedule_output_i() and + cancel_output_i() and they are made private, because only the + Reactive_Flushing_Strategy should invoke them. + + * tao/Transport.cpp: + * tao/PortableServer/Object_Adapter.cpp: + Move the instantiation of ACE_Reverse_Lock<ACE_Lock> to the + Transport.cpp file. + + * tests/AMI/muxed.conf: + * tests/AMI/exclusive.conf: + Fixed use of obsolete options + + * tests/AMI/run_test.pl: + Cosmetic fixes + + Mon Apr 23 11:54:23 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/AMI_Buffering/AMI_Buffering.dsw: + * tests/AMI_Buffering/admin.dsp: + * tests/AMI_Buffering/client.dsp: + * tests/AMI_Buffering/server.dsp: + Add MSVC project files for this test + + Mon Apr 23 11:47:07 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/AMI_Buffering/Client_Task.h: + * tests/AMI_Buffering/Client_Task.cpp: + * tests/AMI_Buffering/client.cpp: + The client event loop can be explicitly terminated now. + + * tests/AMI_Buffering/run_timeout_reactive.pl: + Add new driver script for timeout based flushing, but initiated + via the Reactor. + + * tests/Oneway_Buffering/client.cpp: + Renamed the second part of the test, 'liveness' is a more + descriptive term. + + Mon Apr 23 10:38:28 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/AMI_Buffering/svc.conf: + Without connection muxing the test runs out of resources pretty + fast, plus flushing does not work exactly as expected. + + * tests/AMI_Buffering/Client_Task.h: + * tests/AMI_Buffering/Client_Task.cpp: + Add thread on the client to invoke the reply handler. Without + this feature the ORB would soon dead-lock. + + Mon Apr 23 10:03:31 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.h: + * tao/Transport.inl: + * tao/Transport.cpp: + Reduce locking overhead by sharing the event handler mutex and + the queue mutex. Since we need to lock the queue just before we + do any I/O it is a very natural fit, and saves us one mutex + per-call. + + Sun Apr 22 19:54:09 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/TAO.dsp: + Update list of files. + + Sun Apr 22 19:32:55 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/README: + * tests/Makefile: + * tests/Makefile.bor: + * tests/AMI_Buffering/README: + * tests/AMI_Buffering/Makefile: + * tests/AMI_Buffering/Makefile.bor: + * tests/AMI_Buffering/admin.bor: + * tests/AMI_Buffering/client.bor: + * tests/AMI_Buffering/server.bor: + * tests/AMI_Buffering/run_test.pl: + * tests/AMI_Buffering/run_timeout.pl: + * tests/AMI_Buffering/run_buffer_size.pl: + * tests/AMI_Buffering/run_message_count.pl: + * tests/AMI_Buffering/Test.idl: + * tests/AMI_Buffering/AMI_Buffering.h: + * tests/AMI_Buffering/AMI_Buffering.cpp: + * tests/AMI_Buffering/AMI_Buffering_Admin.h: + * tests/AMI_Buffering/AMI_Buffering_Admin.cpp: + * tests/AMI_Buffering/Reply_Handler.h: + * tests/AMI_Buffering/Reply_Handler.cpp: + * tests/AMI_Buffering/admin.cpp: + * tests/AMI_Buffering/client.cpp: + * tests/AMI_Buffering/server.cpp: + + Fri Apr 20 15:29:13 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Makefile: + * tao/Makefile.bor: + * tao/Queued_Message.h: + * tao/Transport.h: + * tao/Transport.inl: + * tao/Transport.cpp: + * tao/Transport_Timer.h: + * tao/Transport_Timer.cpp: + Add support for timeout notifications from the Reactor. This is + used to implement the TIMEOUT buffering constraints when the + application does not send events continously. + + * tests/Oneway_Buffering/client.cpp: + * tests/Oneway_Buffering/run_test.pl: + * tests/Oneway_Buffering/run_timeout_reactive.pl: + Add new regression test to verify that the TIMEOUT buffering + constraints work. + + Thu Apr 19 14:17:38 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.h: + * tao/Transport.cpp: + Factor out common code in drain_queue_i() into + drain_queue_helper(). + Factor out code in send_message_queue(), incidentally + send_message_queue() did not grab the queue lock, fixed that + oversight. + Made TAO_Block_Flushing_Strategy a friend class to access a + couple of _i() methods. + + * tao/Synch_Queued_Message.cpp: + Sometimes the message block chain contain trailing empty + elements. Those elements must be skipped, otherwise the + current_block_ field never becomes 0, even though there is no + more data to send. + + * tao/Block_Flushing_Strategy.cpp: + In the blocking flush strategy we need to drain the queue as + soon as schedule_output() is called, otherwise it is possible + that the queue will never be drained. + + * tests/Queued_Message_Test/Queued_Message_Test.cpp: + Use the TAO_Async_Queued_Message class for the test, the base + class is abstract now. + + * tests/Oneway_Buffering/client.cpp: + Initialize payload with non-zero bytes for easier debugging + + * tests/LongWrites/Makefile: + Add files missed during the merge + + * tests/Big_Request_Muxing/Makefile: + Update dependencies + + * tests/Big_Request_Muxing/client.cpp: + Made request payload smaller, it was taking too long to run + otherwise. + + * tests/Big_Request_Muxing/Client_Task.cpp: + Made the test less verbose + + * tests/Makefile: + Add a couple of missing tests Big_Twoways and Big_Request_Muxing + + * performance-tests/Latency/client.conf: + Made output path blocking, using reactive out with blocking + input does not quite work. + + * examples/Buffered_AMI/test.idl: + * tests/Reliable_Oneways/Test.idl: + * tests/Blocking_Sync_None/Test.idl: + Made shutdown() operation a twoway. + + * examples/Buffered_AMI/client.cpp: + Change ReplyHandler to receive the shutdown() callback. + + * tests/Muxing/run_test.pl: + * examples/Buffered_AMI/run_test.pl: + Increased wait time for the IOR file. + + Tue Apr 17 19:12:31 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.cpp: + Reset the current deadline as soon as the queue is empty. + + * tao/Sync_Strategies.cpp: + Add debugging messages + + * tao/Makefile: + * tao/Message_Sent_Callback.h: + * tao/Message_Sent_Callback.inl: + * tao/Message_Sent_Callback.cpp: + * tao/Queued_Message.h: + * tao/Queued_Message.cpp: + Removed the TAO_Message_Sent_Callback class, it was not required + at all. + + * tao/Strategies/UIOP_Transport.cpp: + Add missing function (removed during the merge). + + Tue Apr 17 14:21:23 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Queued_Message.h: + * tao/Asynch_Queued_Message.h: + * tao/Asynch_Queued_Message.cpp: + * tao/Synch_Queued_Message.h: + The bytes_transferred() method does not need to return anything, + the return value was ignored anyway, so change it to return + void. + + * tao/Synch_Queued_Message.cpp: + Fixed implementation of bytes_transferred(), the byte_count + argument was not updated on all exit branches. + + * tao/GIOP_Message_Handler.cpp: + Fixed inconsistency with main trunk. + + * tao/Sync_Strategies.cpp: + Set the must_flush and set_timer flags to zero if there is no + buffering constraint policy. + + * tao/Transport.cpp: + Cosmetic fixes. Return 1 from drain_queue_i() even if the flush + operation returned 0, the return value is supposed to represent + what happened to the message, not if there was a generic problem + with the ORB. + + Tue Apr 17 09:59:38 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Sync_Strategies.h: + * tao/Sync_Strategies.cpp: + Add an argument in buffering_constraints_reached(), this new + argument represents the current deadline for the transport. + The current deadline is used to determine if the timer needs to + be reset or if the timer has already expired. + Unless the flushing strategy is turned on we need to check the + timers on all exit paths. + + Change TAO_Transport_Sync_Strategy to *always* flush and always + schedule output on every request. + + * tao/Transport.h: + * tao/Transport.cpp: + Use the new interface in the sync strategies to activate the + output as soon as the timer expires. Keep track of the current + deadline for scheduling output. + Fixed boundary condition in drain_queue_i(), there is a while() + loop to fill iovecs with the contents of the queue, it is + possible to exit the loop without anything in the iovec. In + this case we don't want to attempt a send() call. + Remove unused argument from the send_synchronous_message_i() + method. + + Sat Apr 14 17:04:21 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.cpp (send_synchronous_message_i): + The message was left in the queue even if a problem was detected + in the write() operation. + + Sat Apr 14 17:01:05 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/TAO.dsp: + Complete merge for Win32, CVS' automatic merge was not quite the + right thing for this file. + + * tao/BiDir_Policy_i.cpp: + This file was removed in the main trunk but was accidentally + resurrected during the merge. + + Sat Apr 14 12:59:39 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Block_Flushing_Strategy.h: + * tao/Block_Flushing_Strategy.cpp: + * tao/Flushing_Strategy.h: + * tao/Flushing_Strategy.cpp: + * tao/Message_Sent_Callback.h: + * tao/Message_Sent_Callback.inl: + * tao/Message_Sent_Callback.cpp: + * tao/Queued_Message.h: + * tao/Queued_Message.inl: + * tao/Queued_Message.cpp: + * tao/Reactive_Flushing_Strategy.h: + * tao/Reactive_Flushing_Strategy.cpp: + Add files lost during merge + + * tao/IIOP_Transport.cpp: + Solve merging problems. + + * tests/Big_Oneways/Makefile: + * tests/Big_Twoways/Makefile: + Update dependencies + + Sat Apr 14 10:33:47 2001 Carlos O'Ryan <coryan@uci.edu> + + * Another merge for the bug 132 fixes. + + Fri Apr 13 18:49:32 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Flushing_Strategy.h: + * tao/Block_Flushing_Strategy.h: + * tao/Block_Flushing_Strategy.cpp: + * tao/Reactive_Flushing_Strategy.h: + * tao/Reactive_Flushing_Strategy.cpp: + Add timeout to the flush_message() operation. + + * tao/Transport.cpp: + Use the new timeout of flush_message() to implement timeouts + for twoways blocked during writes. + + * tao/Queued_Message.h: + * tao/Queued_Message.cpp: + Add method to insert message at the head of the queue. + + * tao/Synch_Queued_Message.h: + * tao/Synch_Queued_Message.cpp: + Add accessor to obtain the current message block. + + Thu Apr 12 20:15:22 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Sync_Strategies.h: + * tao/Sync_Strategies.cpp: + Use two separate flags to return if: + (1) the queue should be immediately flushed + (2) and/or the ORB should start draining the queue + + * tao/Transport.h: + * tao/Transport.cpp: + Use the new interface in TAO_Sync_Strategy to correctly + implement TAO::BUFFER_MESSAGE_COUNT and the TAO::BUFFER_SIZE + buffering constraint policies. + + Wed Apr 11 10:21:35 2001 Carlos O'Ryan <coryan@uci.edu> + + * With the following changes the semantics of oneways are + bug-compatible with the main trunk. + + * tao/Transport.cpp: + Add new method to check if the transport queue has any data + pending. + + * tao/Flushing_Strategy.h: + Add new operation to block until the queue becomes completely + empty. + + * tao/Block_Flushing_Strategy.h: + * tao/Block_Flushing_Strategy.cpp: + * tao/Reactive_Flushing_Strategy.h: + * tao/Reactive_Flushing_Strategy.cpp: + Implement flush_transport() in each concrete strategy. + + * tao/Transport.h: + Remove old code that was commented out anyway. + + Mon Apr 09 00:41:20 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Invocation.cpp: + The default scope should be SYNC_WITH_TRANSPORT, but was + overriden and became SYNC_NONE. + + * tao/Reactive_Flushing_Strategy.cpp: + Fixed conditions to terminate the loop. + + * tao/Transport.cpp: + Initialize byte_count to zero before calling send(), add more + ACE_ASSERT() calls to debug the system. + + Sat Apr 7 21:13:48 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.cpp: + Separate the path for synchronous and asynchronous requests more + cleanly. + Merge the close_connection() changes from the main trunk, the + ORB was dead-locking on me. + Improve output for sent iovectors, now it is only generated if + TAO_debug_level==2 and the Log_Msg is locked to prevent other + threads from dumping the same messages. + + * tao/Transport.cpp (drain_queue_i): + New method used by the synchronous path to send data ASAP. + + * tao/Invocation.h: + * tao/Invocation.cpp (invoke): + Clarify the semantics of the <twoway_flag> argument, actually it + means that the ORB should wait until the data is delivered to + the wire. + Oneway invocations with the SYNC_WITH_TRANSPORT policy should + block until the data is delivered to the wire. + + * tao/GIOP_Message_Handler.cpp: + Only print the full contents of the received data when the debug + level is *exactly* 2. + + * tests/Big_Oneways/Session.cpp: + Fill up the messages with a repeating pattern, this is useful + during debugging. + + Thu Apr 05 10:36:57 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Queued_Message.h: + Remove the declaration of the done() method, the semantics were + not clear and it was removed a couple of iterations ago. + + * tao/Block_Flushing_Strategy.cpp: + * tao/Reactive_Flushing_Strategy.cpp: + Wait until all_data_sent() returns. + + * tao/Transport.cpp: + Cleanup handle_output() no need to loop, the drain_queue() + method does that. + After trying to send a message and blocking the send_message_i() + method was not updating the new Asynch_Queued_Message with the + number of bytes sent. + drain_queue() loop was too complicated for its own sake. + + * tests/Big_Oneways/Session.h: + * tests/Big_Oneways/Test.idl: + * tests/Big_Oneways/Session.cpp: + Add methods to prime the connections among multiple clients. + + * tests/Big_Oneways/server.cpp: + Increase timeout for initial session registration. Important + for manual executions. + + Wed Apr 4 10:53:27 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.h: + * tao/Transport.cpp: + Remove dead code. + Rename some methods to more clearly reflect their intent. + Simplify the management for the outgoing data queue. The + cleanup_queue() method removes any element that is completely + sent, while the drain_queue() method simply tries to send as + much data as possible. + + * tao/Queued_Message.h: + * tao/Queued_Message.inl: + * tao/Queued_Message.cpp: + Each derived class can decided if the message has been + completely sent very efficiently, no need to keep a local + variable for that. + We do need variables to keep track of closed connections, failed + sends and timeouts. + + * tao/Messaging_Policy_i.cpp: + * tao/Invocation.cpp: + Improved debugging messages for timeouts + + Sun Apr 01 15:34:32 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Makefile: + * tao/TAO.dsp: + * tao/TAO_Static.dsp: + * tao/Asynch_Queued_Message.h: + * tao/Asynch_Queued_Message.cpp: + * tao/Synch_Queued_Message.h: + * tao/Synch_Queued_Message.cpp: + * tao/Queued_Message.h: + * tao/Queued_Message.inl: + * tao/Queued_Message.cpp: + Specialize the Queue_Message class for Synchronous and + Asynchronous messages. Their behavior is completely different: + synchronous messages (twoways and reliable oneways) are + allocated from the stack, they should not copy the CDR stream + and thus have to deal with message block chains. + Asynchronous messages (oneways and AMIs with SYNC_NONE policy) + are allocated from the heap, they must copy their data and thus + can reassemble it in a single buffer. + + * tao/Transport.h: + * tao/Transport.cpp: + Changed the transport to use the new interface in the + Queued_Message class. + Completely separate the synchronous and asynchronous operation + path. + The new implementation recovers some functionality lost in + previous revisions: multiple messages can be sent in a single + iovector. + + * tests/Big_Oneways/Test.idl: + * tests/Big_Oneways/Session.h: + * tests/Big_Oneways/Session.cpp: + Add ping() operation to the Session IDL interface. + This is used to validate the session during startup, i.e. ensure + that enough connections are available for all the threads. + + Sat Mar 31 14:56:37 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.cpp: + Fixed memory management and synchronization problems. + Invoke the connection_closed() method on all the pending + messages if the connection is closed. + + * tao/Queued_Message.h: + * tao/Queued_Message.inl: + * tao/Queued_Message.cpp: + If the connection is closed there is no sense in trying to + continue sending the message. + The done() method returns 1 if the connection was closed or if + the message was completely sent. + + * tao/Reactive_Flushing_Strategy.cpp: + Propagate any errors from Transport::schedule_output() and + Transport::cancel_output() + + * tests/Big_Request_Muxing/Big_Request_Muxing.dsw: + * tests/Big_Request_Muxing/client.dsp: + * tests/Big_Request_Muxing/server.dsp: + Add MSVC project files + + Fri Mar 30 17:06:33 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/README: + * tests/Big_Request_Muxing/README: + * tests/Big_Request_Muxing/Test.idl: + * tests/Big_Request_Muxing/run_test.pl: + * tests/Big_Request_Muxing/Makefile: + * tests/Big_Request_Muxing/Client_Task.h: + * tests/Big_Request_Muxing/Client_Task.cpp: + * tests/Big_Request_Muxing/Payload_Receiver.h: + * tests/Big_Request_Muxing/Payload_Receiver.cpp: + * tests/Big_Request_Muxing/client.cpp: + * tests/Big_Request_Muxing/server.cpp: + * tests/Big_Request_Muxing/svc.conf: + Another regression tests, use the same connection to the big + oneways at different levels of reliability. + + * tests/README: + * tests/Big_Twoways/README: + * tests/Big_Twoways/Test.idl: + * tests/Big_Twoways/run_test.pl: + * tests/Big_Twoways/Makefile: + * tests/Big_Twoways/Coordinator.h: + * tests/Big_Twoways/Coordinator.cpp: + * tests/Big_Twoways/Peer.h: + * tests/Big_Twoways/Peer.cpp: + * tests/Big_Twoways/Session.h: + * tests/Big_Twoways/Session.cpp: + * tests/Big_Twoways/Session_Control.h: + * tests/Big_Twoways/Session_Control.cpp: + * tests/Big_Twoways/Session_Task.h: + * tests/Big_Twoways/Session_Task.cpp: + * tests/Big_Twoways/client.cpp: + * tests/Big_Twoways/server.cpp: + Another regression test, similar to Big_Oneways, but this one + uses a long request *and* a long reply. + + * tests/LongWrites/Sender.cpp: + Fixed warning about unused variable + + * tests/LongWrites/Makefile: + Fixed Makefile + + * tests/Timeout/client.cpp: + Verify that at least some of the messages timeout and others + complete the test successfully. + + Thu Mar 29 08:38:42 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/IIOP_Transport.cpp: + * tao/Strategies/SHMIOP_Transport.cpp: + * tao/Strategies/UIOP_Transport.cpp: + * orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.cpp: + Do not close the connection if it sends 0 bytes. This is + perfectly possible when using non-blocking I/O. + + Wed Mar 28 10:42:12 2001 Carlos O'Ryan <coryan@uci.edu> + + * Another merge for the branch fixing bug 132 + + Tue Mar 20 09:34:53 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.cpp: + Improved error checking for Queued_Message allocations. + + Sat Mar 17 17:52:27 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.h: + * tao/Transport.cpp: + Removed the current_message_ field, using the head of the queue + works just as well, at least as long as we always push events to + the end of the queue. + + * tao/IIOP_Transport.h: + * tao/IIOP_Transport.cpp: + * tao/Reactive_Flushing_Strategy.cpp: + Use the Flushing Strategy to schedule output and cancel output + with the reactor. + + Sat Mar 17 15:34:14 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/Big_Oneways/Session.h: + * tests/Big_Oneways/Session.cpp: + Fixed signed/unsigned warnings + + * tests/Big_Oneways/Coordinator.cpp: + Print error messages in all exception cases + + * tests/Big_Oneways/run_test.pl: + Run 3 peers to cause failures. + + Fri Mar 16 15:49:26 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/IIOP_Transport.cpp: + Fixed debugging message for cancel_output. + + * tests/Big_Oneways/Big_Oneways.dsw: + * tests/Big_Oneways/client.dsp: + * tests/Big_Oneways/server.dsp: + Fixed project files, the first version commited missed some + changes. + + Thu Mar 15 10:46:52 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/Big_Oneways/Makefile: + * tests/Big_Oneways/Test.idl: + * tests/Big_Oneways/run_test.pl: + * tests/Big_Oneways/Coordinator.h: + * tests/Big_Oneways/Coordinator.cpp: + * tests/Big_Oneways/Peer.h: + * tests/Big_Oneways/Peer.cpp: + * tests/Big_Oneways/Session.h: + * tests/Big_Oneways/Session.cpp: + * tests/Big_Oneways/client.cpp: + * tests/Big_Oneways/server.cpp: + Changed the test to work more predictably on multi-CPU boxes. + The sessions are configured at creation time, and they don't + start sending events until start() is called. + Instead of automatically destroy them on shutdown we wait until + they all stop and then explicitly use a destroy() method to take + them down. + + Tue Mar 13 15:08:06 2001 Carlos O'Ryan <coryan@uci.edu> + + * tests/README: + * tests/Makefile: + * tests/Big_Oneways/README: + * tests/Big_Oneways/Test.idl: + * tests/Big_Oneways/Makefile: + * tests/Big_Oneways/Big_Oneways.dsw: + * tests/Big_Oneways/server.dsp: + * tests/Big_Oneways/client.dsp: + * tests/Big_Oneways/run_test.pl: + * tests/Big_Oneways/Coordinator.h: + * tests/Big_Oneways/Coordinator.cpp: + * tests/Big_Oneways/Peer.h: + * tests/Big_Oneways/Peer.cpp: + * tests/Big_Oneways/Session.h: + * tests/Big_Oneways/Session.cpp: + * tests/Big_Oneways/Session_Control.h: + * tests/Big_Oneways/Session_Control.cpp: + * tests/Big_Oneways/Session_Task.h: + * tests/Big_Oneways/Session_Task.cpp: + * tests/Big_Oneways/client.cpp: + * tests/Big_Oneways/server.cpp: + Add new stress test for the non-blocking I/O features in the + ORB. This test is more focussed than LongWrites, and its + shutdown sequence is better designed (LongWrites tends to crash + after running successfully.) + + * tao/GIOP_Message_Handler.cpp: + Fixed unsigned/signed warning + + Thu Mar 8 19:12:48 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/GIOP_Message_Base.cpp: + * tao/GIOP_Message_Handler.h: + * tao/GIOP_Message_Handler.cpp: + Had to manually merge Bala's changes from Sat Feb 17 23:08:44 + 2001. + + * tao/IIOP_Connection_Handler.cpp: + Cosmetic fixes. + + * tao/IIOP_Transport.cpp: + Print debugging messages when output is scheduled, and alse when + it is canceled. + Do not register the handler more than once on the reactor. + + * tao/Queued_Message.inl: + The done() condition was reversed. + + * tao/Transport.cpp: + Add a ton of debugging mesages, including detailed messages of + outgoing and incoming data, information about each queued + message, etc. + + * tao/Transport.cpp (send_message_block_chain): + Always add the number of bytes transferred on each send() call, + even when it returns an error. + + * tao/Transport.cpp (send_message_i): + Use easier to read code when deciding what messages are queued. + Before calling schedule_output() and returning we must queue the + message, forgot to do that in the previous version. + + * tests/LongWrites/Receiver.cpp: + * tests/LongWrites/Sender.cpp: + * tests/LongWrites/Sender.h: + * tests/LongWrites/Sender_Task.cpp: + * tests/LongWrites/Sender_Task.h: + * tests/LongWrites/client.cpp: + I'm tweaking the test trying to make the termination condition + more reliable. Unfortunately after one of the clients finishes + the rest does not receive all the required messages. + I will probably have to change the protocol, which is probably a + good idea anyway, so we can control the number of threads too. + + * tests/LongWrites/run_test.pl: + In the haste to merge the fix_bug132 bug I forgot to incorporate + the support for the multiple test types. + + * tao/Makefile: + * tao/Domain/Makefile: + * tao/DynamicAny/Makefile: + * tao/DynamicInterface/Makefile: + * tao/IFR_Client/Makefile: + * tao/IORManipulation/Makefile: + * tao/IORTable/Makefile: + * tao/PortableServer/Makefile: + * tao/SmartProxies/Makefile: + * tao/Strategies/Makefile: + * tests/LongWrites/Makefile: + Update dependencies. + + Wed Mar 07 08:48:11 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Queued_Message.inl: + Both done() and mb() were using contents_, but the flow has + changed to use current_message_. + + * tao/Transport.cpp: + Simplify code flow in send_current_message() + Simplify code in dequeue_head() + + * tao/TAO.dsp: + * tao/TAO_Static.dsp: + Update project files so they work on the branch. + + Tue Mar 6 19:44:44 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/GIOP_Message_Handler.cpp: + When printing an invalid GIOP magic number use hex values, not + the character representation, because the latter can print out + garbage. + + * tao/ORB_Core.cpp: + Print the return value of each handle_events() call, on an + attempt to figure out why it is spinning. + + * tao/Transport.cpp: + Print handle, return value and errno after each call to + send_current_message() + + * tao/Wait_On_Leader_Follower.cpp: + Don't enter the event loop if the reply has been received + already. + + Tue Mar 6 11:02:43 2001 Carlos O'Ryan <coryan@uci.edu> + + * Merged in changes from the fix_bug132 branch. I need several + bug fixes from the main trunk. In my experience the easiest way + to do this is to create a new branch higher up in the main + trunk, close the old branch and propagate its changes to the new + one. + In this case we created fix_bug132_iter02 (today) merge the + changes from fix_bug132 into that branch, and close fix_bug132. + + Mon Mar 5 11:32:14 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.cpp: + * tao/IIOP_Transport.cpp: + Add debugging messages + + * tests/LongWrites/Makefile: + Updates dependencies and object files for the client. + + Fri Mar 02 15:29:17 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.h: + * tao/Transport.cpp: + Continue implementation of reactive output. + On this pass I fixed the code to deal with several error + conditions, invoke schedule_output() if the connection returns + an EWOULDBLOCK, also cancel the output if there is no data to + send. + Fix syncronization on send_queued_message() + Fix memory allocation for message blocks contained in + Queued_Message, they cannot be cloned() because that would + allocate from TSS. + + * tao/IIOP_Transport.h: + * tao/IIOP_Transport.cpp: + Implement schedule_output() and cancel_output() methods. + + * tao/Wait_On_Leader_Follower.cpp: + Do not re-insert the transport into the reactor on each wait, + once is enough. + + * tao/IIOP_Connection_Handler.h: + * tao/IIOP_Connection_Handler.cpp: + Implement a handle_output() callback, delegate on the + TAO_Transport + + * tao/IIOP_Endpoint.cpp: + Remove unused #include + + * tests/LongWrites/Coordinator.h: + * tests/LongWrites/Coordinator.cpp: + * tests/LongWrites/Receiver.h: + * tests/LongWrites/Receiver.cpp: + * tests/LongWrites/Sender.h: + * tests/LongWrites/Sender.cpp: + * tests/LongWrites/client.cpp: + * tests/LongWrites/client.dsp: + * tests/LongWrites/run_test.pl: + * tests/LongWrites/server.cpp: + * tests/LongWrites/svc.conf: + * tests/LongWrites/Sender_Task.h: + * tests/LongWrites/Sender_Task.cpp: + Add support for multi-threaded clients. + Try to count the number of incoming messages and only exit when + all have been received. + + * tests/Queued_Message_Test/Queued_Message_Test.dsp: + Removed a number of unused files from this unit test. + + Sun Feb 25 10:22:59 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Queued_Message.h: + * tao/Queued_Message.cpp: + * tao/Transport.cpp: + Instead of releasing the message blocks as soon as possible we + delay until the queued message is deallocated. This will make + it possible to release all the data in the same thread that + allocated it, preserving the support for TSS allocators. + + * tests/LongWrites/Test.idl: + * tests/LongWrites/Receiver.h: + * tests/LongWrites/Receiver.cpp: + * tests/LongWrites/Sender.h: + * tests/LongWrites/Sender.cpp: + * tests/LongWrites/client.cpp: + * tests/LongWrites/run_test.pl: + The test can now send big oneways, big twoways and big twoways + with big responses. + + Wed Feb 14 18:38:11 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Queued_Message.cpp: + Fixed queue manipulation logic + + * tests/Queued_Message_Test/Queued_Message_Test.cpp: + The test was miscounting remove operations from the queue. + + * tests/Queued_Message_Test/Queued_Message_Test.dsw: + * tests/Queued_Message_Test/Queued_Message_Test.dsp: + Add MSVC project files. + + Wed Feb 14 10:02:44 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Queued_Message.h: + * tao/Queued_Message.cpp: + Add flag to control message block ownership, used to minimize + memory allocations. + + * tao/Transport.cpp: + Use the ownership flags for the Queued_Message. + + * tests/Makefile: + * tests/Queued_Message_Test/Makefile: + * tests/Queued_Message_Test/Queued_Message_Test.cpp: + Add new unit test for the TAO_Queued_Message class. + + * tao/Makefile: + * tao/Domain/Makefile: + * tao/DynamicAny/Makefile: + * tao/DynamicInterface/Makefile: + * tao/IFR_Client/Makefile: + Update dependencies + + * orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.cpp: + The ACE_SSL_SOCK_Stream does not support sendv() + + Mon Feb 12 15:44:54 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Makefile: + Update makefile to include new files + + * orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.h: + * orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.cpp: + * tao/Strategies/SHMIOP_Transport.h: + * tao/Strategies/SHMIOP_Transport.cpp: + * tao/Strategies/UIOP_Transport.h: + * tao/Strategies/UIOP_Transport.cpp: + Fixed all protocols to use the new send() method with iovec + parameters. + + * tao/GIOP_Message_Lite.cpp: + Use the send() method with iovec arguments. + + * tao/Sync_Strategies.h: + * tao/Sync_Strategies.cpp: + * tao/Transport.cpp: + More cleanup for the Sync_Strategies, the must_queue() method + does not require a Stub argument. + + Mon Feb 12 10:15:47 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Transport.h: + * tao/Transport.cpp: + Add new method to send a message block chain. + The template method to send data takes an iovec argument. + + * tao/IIOP_Transport.h: + * tao/IIOP_Transport.cpp: + Implement the iovec-based send() template method. + + * tao/Queued_Message.cpp: + The cleanup code was broken. + + * tao/GIOP_Message_Base.cpp: + Use the message block chain method to send short critical + messages. + + Fri Feb 09 10:50:47 2001 Carlos O'Ryan <coryan@uci.edu> + + * tao/Queued_Message.h: + * tao/Queued_Message.inl: + * tao/Queued_Message.cpp: + Add new class to represent a queued message in the outgoing + path. This class has to keep more than just the message block, + it also takes care of timeouts and signaling any waiting thread + when the message is sent. + + * tao/Message_Sent_Callback.h: + * tao/Message_Sent_Callback.inl: + * tao/Message_Sent_Callback.cpp: + Define interface to signal threads waiting for a message to be + sent out, e.g. twoway requests blocked waiting for a queued + message. + + * tao/Flushing_Strategy.h: + * tao/Flushing_Strategy.cpp: + * tao/Block_Flushing_Strategy.h: + * tao/Block_Flushing_Strategy.cpp: + * tao/Reactive_Flushing_Strategy.h + * tao/Reactive_Flushing_Strategy.cpp: + New classes to control how the outgoing data is flushed, + either by blocking on write() or by using the reactor. + + * tao/Resource_Factory.h: + * tao/default_resource.h: + * tao/default_resource.cpp: + Add new methods to create the flushing strategy. + + * tao/ORB_Core.h: + * tao/ORB_Core.i: + * tao/ORB_Core.cpp: + Add accessor for the flushing strategy. Notice that the + strategy is stateless so a single instance (per-ORB) is needed. + + * tao/Sync_Strategies.h: + * tao/Sync_Strategies.cpp: + The Sync_Strategies have been simplified. They are now + stateless, and they only need to answer a couple of questions + (1) should a message be buffered, (2) should the ORB flush a + queue. + + * performance-tests/Latency/st_client.cpp: + Destroy the ORB on shutdown. + + * tao/TAO.dsp: + * tao/TAO_Static.dsp: + Add the new files to the TAO project files. + + * tao/Transport.h: + * tao/Transport.inl: + * tao/Transport.cpp: + Move much of the functionality of sending and outgoing message + queue up to the base transport class. Remove a lot of code + deailing with the previous (blocking) queues. + + * tao/IIOP_Transport.cpp: + * tao/IIOP_Connection_Handler.cpp: + * tao/Strategies/SHMIOP_Transport.cpp: + * tao/Strategies/SHMIOP_Connection_Handler.cpp: + * tao/Strategies/UIOP_Transport.cpp: + * tao/Strategies/UIOP_Connection_Handler.cpp: + * orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.cpp: + * orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.cpp: + Change the transport and connection handlers to use the new + outgoing message queue, the flushing strategy and the changes to + the SyncStrategy. + + * tao/GIOP_Message_Base.cpp: + Propagate a few interface changes. + + * tests/LongWrites/LongWrites.dsw: + * tests/LongWrites/client.dsp: + * tests/LongWrites/server.dsp: + * tests/LongWrites/run_test.pl: + Got the test to compile (and run) under NT. + Mon Apr 23 11:49:01 2001 Joe Hoffert <joeh@cs.wustl.edu> * TAO_IDL/be/be_visitor_sequence/cdr_op_cs.cpp: diff --git a/TAO/configure.in b/TAO/configure.in new file mode 100644 index 00000000000..609ceadb091 --- /dev/null +++ b/TAO/configure.in @@ -0,0 +1,664 @@ +dnl +dnl $Id$ + +AC_REVISION($Revision 0.6 $)dnl + +dnl +dnl An autoconf script to automatically configure TAO. +dnl Process this file with autoconf to produce a configure script. +dnl + +dnl +dnl The autoconf documentation states that this is the recommended +dnl sequence for this file: +dnl +dnl `AC_INIT(FILE)' +dnl checks for programs +dnl checks for libraries +dnl checks for header files +dnl checks for typedefs +dnl checks for structures +dnl checks for variables +dnl checks for compiler characteristics +dnl checks for library functions +dnl checks for system services +dnl `AC_OUTPUT([FILE...])' +dnl +dnl I followed this convention, and added a few sections. +dnl -- Gonzo + + +dnl +dnl SECTION 1: `AC_INIT(FILE)' +dnl +dnl This macro must be the very first invoked. +dnl Its argument names a file that must exist in the directory where +dnl autoconf will run, just to check things. +dnl AC_INIT(ace_unique.m4) +dnl +AC_INIT(tao/TAO.cpp) + +dnl Require GNU Autoconf 2.13 or better. +AC_PREREQ(2.13) + +dnl Check what platform we are running on. +AC_CANONICAL_SYSTEM + +dnl Allow the standard program name transformations. +dnl We probably don't need AC_ARG_PROGRAM any longer since AM_INIT_AUTOMAKE +dnl handles this functionality. -- Ossama +dnl AC_ARG_PROGRAM + +dnl Cause GNU Automake to initialize the state of things and run +dnl some sanity checks +TAO_PACKAGE="tao" +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl +TAO_VERSION=`head -1 ${srcdir}/VERSION | sed 's/.*version \([0-9.]*\).*/\1/'` +changequote([, ])dnl + +AM_INIT_AUTOMAKE("$TAO_PACKAGE", "$TAO_VERSION", DUMMY) + +dnl Generate a header file with all settings. +dnl AM_CONFIG_HEADER(tao/config.h) + +dnl Move before the AC_ARG_ENABLE stuff to prevent autoconf complaints. +dnl This is a bit messy but it makes life easier for me. +dnl -Ossama +dnl +dnl SECTION: checks for programs +dnl + +dnl Check if system supports "#! /bin/sh" line in scripts +AC_SYS_INTERPRETER + + +dnl Check for ace-config script +AC_CHECK_PROG(ACE_CONFIG, ace-config, ace-config,) dnl +if test -z "$ACE_CONFIG"; then + AC_MSG_WARN(ace-config script not found) + AC_MSG_WARN(TAO may not find all of the necessary ACE related libraries) +fi + +dnl Check the C compiler and preprocessor. +AC_PROG_CC +AC_PROG_CPP +AC_PROG_CC_C_O + +dnl The C++ compiler used to compile TAO must be the same as the one +dnl used to compile ACE. +if test -n $ACE_CONFIG; then + CXX=`$ACE_CONFIG --cxx ace` +fi + +dnl Check the C++ compiler and preprocessor. +AC_PROG_CXX +AC_PROG_CXXCPP + +dnl Disable building of static libraries by default +AC_DISABLE_STATIC + +dnl Enable Libtool module support +AC_LIBTOOL_DLOPEN + +dnl FIXME: Temporary hack to make libtool work with g++. +dnl Shared library support will only work with GNU g++ and GNU ld +dnl right now. +save_CC="$CC" +CC="$CXX" + +dnl Check for libtool and turn on Automake processing for Libtool +AM_PROG_LIBTOOL + +CC="$save_CC" + + +dnl This checks for a binary called gm4, gnum4 or m4, and assigns +dnl whatever was found (or "gonzo") to the M4 macro. +dnl AC_CHECK_PROGS(M4, gm4 gnum4 m4, gonzo) + +dnl Look for the best awk-style program available. +AC_PROG_AWK + +dnl Set some version information +TAO_CURRENT="0" +TAO_AGE="0" +TAO_REVISION="0" + +if test -n "$AWK"; then + TAO_MAJOR=`echo "$TAO_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]1 }'` + TAO_MINOR=`echo "$TAO_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]2 }'` + TAO_BETA=`echo "$TAO_VERSION" | sed 's/\./ /g' | $AWK '{ print \[$]3 }'` + +dnl This is a terrible kludge to fool libtool into making it produce a shared +dnl library with the "right" version information. +dnl We really should switch to a version scheme that is compatible with +dnl libtool. +dnl -Ossama + TAO_CURRENT=`expr $TAO_MAJOR + $TAO_MINOR` + TAO_AGE=$TAO_MINOR + TAO_REVISION=$TAO_BETA +fi + +AC_SUBST(TAO_CURRENT) +AC_SUBST(TAO_AGE) +AC_SUBST(TAO_REVISION) + +dnl Do the usual install settings; don't forget to include a +dnl install-sh script, in case the is no BDS compatible install +dnl installed (no pun intended) in your machine. +dnl +dnl We don't need this anymore since AM_INIT_AUTOMAKE calls AM_PROG_INSTALL +dnl yes "AM_PROG_INSTALL," not "AC_PROG_INSTALL." -- Ossama +dnl AC_PROG_INSTALL + +dnl Special handling for some UNIX variants and Cygwin32 +AC_AIX +AC_ISC_POSIX +AC_MINIX +AC_CYGWIN + +dnl The user's/default C++ flags are stored in "CXXFLAGS." We use +dnl the variable "TAO_CXXFLAGS" to set the C++ flags we want. At the end +dnl of the configuration process we combine TAO_CXXFLAGS and CXXFLAGS +dnl into CXXFLAGS (e.g., CXXFLAGS="$TAO_CXXFLAGS $CXXFLAGS"). CXXFLAGS +dnl goes after TAO_CXXFLAGS so that the user's C++ flag command line +dnl choices always override the configure script's choices. +TAO_CXXFLAGS="" +TAO_CFLAGS="" + +dnl Set the test language as C++ +AC_LANG_CPLUSPLUS + +dnl Check if we support symlinks +AC_PROG_LN_S + +dnl Check if a lexical analyzer exists (lex, flex, etc.) +AM_PROG_LEX + +dnl Check if some implementation of YACC exists (yacc, byacc, bison, etc.) +AC_PROG_YACC +dnl if test -z "$YACC"; then +dnl ./missing yacc +dnl fi + +dnl We actually check for this in the user AC_ARG_WITH(--with-gperf) +dnl block since it is more convenient to put it there. +dnl Check for gperf program +dnl AC_CHECK_PROGS(GPERF, gperf-ace gperf,) dnl + +dnl Check for profiling progam +AC_CHECK_PROGS(PROF, gprof prof,) dnl + + +dnl +dnl SECTION 2: Configure script command line options +dnl +AC_ARG_ENABLE(fast, + [ --enable-fast enable -fast flag, e.g. Sun C++ [default=no]], + [ + case "${enableval}" in + yes) + TAO_CXXFLAGS="$TAO_CXXFLAGS -fast" + TAO_CFLAGS="$TAO_CFLAGS -fast" + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-fast) + ;; + esac + ],) + +AC_ARG_ENABLE(messaging, + [ --enable-messaging enable CORBA messaging support [default=yes]], + [ + case "${enableval}" in + yes) + AC_DEFINE(TAO_HAS_CORBA_MESSAGING) + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-messaging) + ;; + esac + ], + [ + AC_DEFINE(TAO_HAS_CORBA_MESSAGING) + ]) + +AC_ARG_ENABLE(minimum-corba, + [ --enable-minimum-corba enable minimum CORBA support [default=no]], + [ + case "${enableval}" in + yes) + AC_DEFINE(TAO_HAS_MINIMUM_CORBA) + ;; + no) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-minimum-corba) + ;; + esac + ],) + +AC_ARG_ENABLE(optimize, + [ --enable-optimize enable additional optimizations [default=no]], + [ + case "${enableval}" in + yes) + AC_MSG_WARN(Optimization configure support not implemented yet.) + ;; + no) + AC_MSG_WARN(Optimization configure support not implemented yet.) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-optimize) + ;; + esac + ],) + +AC_ARG_ENABLE(profile, + [ --enable-profile enable profiling [default=no]], + [ + case "${enableval}" in + yes) + if test -z "$PROF"; then + AC_MSG_WARN(No profiling program found. Assuming 'prof' exists) + TAO_CXXFLAGS="$TAO_CXXFLAGS -p" + TAO_CFLAGS="$TAO_CFLAGS -p" + else + case "$PROF" in + gprof) + echo "Building with 'gprof' support" + TAO_CXXFLAGS="$TAO_CXXFLAGS -pg" + TAO_CFLAGS="$TAO_CFLAGS -pg" + ;; + prof) + echo "Building with 'prof' support" + TAO_CXXFLAGS="$TAO_CXXFLAGS -p" + TAO_CFLAGS="$TAO_CFLAGS -p" + ;; + *) + dnl We shouldn't get here. + AC_MSG_WARN(Assuming 'prof' exists) + TAO_CXXFLAGS="$TAO_CXXFLAGS -p" + TAO_CFLAGS="$TAO_CFLAGS -p" + ;; + esac + fi + ;; + no) + dnl Do nothing + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-profile) + ;; + esac + ],) + +AC_ARG_ENABLE(purify, + [ --enable-purify Purify all executables [default=no]], + [ + case "${enableval}" in + yes) + AC_CHECK_PROG(PURIFY, purify, purify,) + if test -n "$PURIFY"; then + PURE_CACHE_BASE_DIR="/tmp/purifycache" + PURE_CACHE_DIR=${PURE_CACHE_BASE_DIR}-${LOGNAME}-${notdir ${CXX} } + PURELINK="$PURIFY -best-effort -chain-length=20 \ + -cache-dir=$PURE_CACHE_DIR \ + -fds-inuse-at-exit=no -ignore-signals=SIGINT -inuse-at-exit \ + -max_threads=100" + TAO_CXXFLAGS="$TAO_CXXFLAGS -DTAO_HAS_PURIFY" + TAO_CFLAGS="$TAO_CFLAGS -DTAO_HAS_PURIFY" + else + AC_MSG_WARN(Purify program was not found.) + AC_MSG_WARN(Disabling purify support.) + fi + ;; + no) + PURELINK="" + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-purify) + ;; + esac + ], PURELINK="") + +AC_ARG_ENABLE(quantify, + [ --enable-quantify Quantify all executables [default=no]], + [ + case "${enableval}" in + yes) + AC_CHECK_PROG(QUANTIFY, quantify, quantify,) + if test -n "$QUANTIFY"; then + PURE_CACHE_BASE_DIR="/tmp/purifycache" + PURE_CACHE_DIR=${PURE_CACHE_BASE_DIR}-${LOGNAME}-${notdir ${CXX} } + PRELINK="$QUANTIFY -best-effort -max_threads=100 \ + -cache-dir=$PURE_CACHE_DIR" + TAO_CXXFLAGS="$TAO_CXXFLAGS -DTAO_HAS_QUANTIFY" + TAO_CFLAGS="$TAO_CFLAGS -DTAO_HAS_QUANTIFY" + else + AC_MSG_WARN(Quantify program was not found.) + AC_MSG_WARN(Disabling quantify support.) + fi + ;; + no) + PRELINK="" + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-quantify) + ;; + esac + ], PRELINK="") + +AC_ARG_ENABLE(rt-corba, + [ --enable-rt-corba enable Real-Time CORBA support [default=yes]], + [ + case "${enableval}" in + yes) + ;; + no) + AC_DEFINE(TAO_DISABLE_RT_CORBA) + ;; + *) + AC_MSG_ERROR(bad value ${enableval} for --enable-rt-corba) + ;; + esac + ],) + +AC_ARG_WITH(ace-includes, + [ --with-ace-includes=DIR ACE include files are in DIR], + [ + case "${withval}" in + yes) + AC_MSG_ERROR(specify a directory where the 'ace' include directory exists.) + ;; + no) + AC_MSG_ERROR(specify a directory where the 'ace' include directory exists.) + ;; + *) + if test -d "${withval}"; then + ACE_INCLUDEDIR="${withval}" + CXXFLAGS="${CXXFLAGS} -I${ACE_INCLUDEDIR}" + else + AC_MSG_ERROR(header directory '${withval}' does not exist.) + fi + ;; + esac + ],) + +AC_ARG_WITH(ace-libs, + [ --with-ace-libs=DIR ACE library files are in DIR], + [ + case "${withval}" in + yes) + AC_MSG_ERROR(specify a directory where the ACE libraries exist.) + ;; + no) + AC_MSG_ERROR(specify a directory where the ACE libraries exist.) + ;; + *) + if test -d "${withval}"; then + ACE_LIBDIR="${withval}" + LDFLAGS="${LDFLAGS} -L${ACE_LIBDIR}" + else + AC_MSG_ERROR(library directory '${withval}' does not exist.) + fi + ;; + esac + ],) + +AC_ARG_WITH(gperf, + [ --with-gperf=PROG gperf program [default=gperf]], + [ + case "${withval}" in + yes) + AC_MSG_ERROR(Specify the gperf program.) + ;; + no) + AC_MSG_ERROR(Specify the gperf program.) + ;; + *) + AC_CHECK_PROGS(GPERF, ${withval},) dnl + if test -n "$GPERF"; then + AC_DEFINE_UNQUOTED(ACE_GPERF, "${withval}") dnl + else + AC_MSG_ERROR(gperf program ${withval} does not exist.) + fi + ;; + esac + ], + [ + AC_CHECK_PROGS(GPERF, gperf-ace gperf,) dnl + if test -n "$GPERF"; then + AC_DEFINE_UNQUOTED(ACE_GPERF, "${GPERF}") dnl + else + AC_MSG_WARN(No gperf program found. TAO will not use perfect hashing.) + fi + ]) + +dnl Check for a working ACE installation +ac_save_CXXFLAGS="$CXXFLAGS" +ac_save_LDFLAGS="$LDFLAGS" +ac_save_LIBS="$LIBS" +if test -n "$ACE_CONFIG"; then + CXXFLAGS=`$ACE_CONFIG --cxxflags ace` + LDFLAGS=`$ACE_CONFIG --libs-only-L ace` + LIBS=`$ACE_CONFIG --libs-only-l ace` +fi +CXXFLAGS="$ac_save_CXXFLAGS $CXXFLAGS" +LDFLAGS="$ac_save_LDFLAGS $LDFLAGS" +LIBS="$ac_save_LIBS -lACE $LIBS" +AC_MSG_CHECKING(for a working ACE installation) +AC_CACHE_VAL(ac_cv_lib_ace_ace_os_exit, +[ + cat > conftest.$ac_ext <<EOF + +#include <ace/OS.h> +changequote(, )dnl +int main(int argc, char *argv[]) +changequote([, ])dnl +{ + ACE_OS::exit(0); +} +EOF + + if (eval "$CXX -o conftest conftest.$ac_ext $CXXFLAGS $LDFLAGS $LIBS") 2>&5; then + ac_cv_lib_ace_ace_os_exit="yes" + rm -f conftest* + else + ac_cv_lib_ace_ace_os_exit="no" + dnl rm -f conftest* + fi +]) +if test "$ac_cv_lib_ace_ace_os_exit" = "yes"; then + AC_MSG_RESULT(yes) +else + AC_MSG_RESULT(no) + AC_MSG_WARN(no functional ACE library found) + AC_MSG_ERROR(specify needed compiler flags using CXXFLAGS variable first) +fi + +dnl We only set the following if the ace-config script doesn't exist! +if test -z "$ACE_CONFIG"; then + + dnl Check if platform supports exceptions using ACE headers + AC_MSG_CHECKING(if ACE supports exceptions) + AC_EGREP_CPP(TAO_EXCEPTIONS, + [ +#include <ace/config.h> + +#if defined (ACE_HAS_EXCEPTIONS) + TAO_EXCEPTIONS +#endif + ], + [ + AC_MSG_RESULT(yes) + ] , + [ + AC_MSG_RESULT(no) + if test -n "$GXX"; then +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl + if g++ --version | egrep -v '^2\.[0-7]' > /dev/null; then +changequote([, ])dnl + if test -z "$ACE_CONFIG"; then + TAO_CXXFLAGS="$TAO_CXXFLAGS -fno-exceptions" + fi + fi + fi + if test -n "$GCC"; then +dnl Temporarily change M4 quotes to prevent "regex []" from being eaten +changequote(, )dnl + if gcc --version | egrep -v '^2\.[0-7]' > /dev/null; then +changequote([, ])dnl + if test -z "$ACE_CONFIG"; then + TAO_CFLAGS="$TAO_CFLAGS -fno-exceptions" + fi + fi + fi + ]) + + dnl Check if platform supports run-time type identification using ACE headers + AC_MSG_CHECKING(if ACE supports GNU C++ repositories) + AC_EGREP_CPP(TAO_GNU_REPO, + [ +#include <ace/config.h> + +#if defined (ACE_HAS_GNU_REPO) + TAO_GNU_REPO +#endif + ], + [ + AC_MSG_RESULT(yes) + if test -n "$GXX" && test -z "$ACE_CONFIG"; then + TAO_CXXFLAGS="$TAO_CXXFLAGS -frepo" + fi + ] , + [ + AC_MSG_RESULT(no) + if test -n "$GXX" && test -z "$ACE_CONFIG"; then + TAO_CXXFLAGS="$TAO_CXXFLAGS -fno-implicit-templates" + fi + ]) + + dnl Check if platform supports run-time type identification using ACE headers + AC_MSG_CHECKING(if ACE supports run-time type identification) + AC_EGREP_CPP(TAO_RTTI, + [ +#include <ace/config.h> + +#if !defined (ACE_LACKS_RTTI) + TAO_RTTI +#endif + ], + [ + AC_MSG_RESULT(yes) + if test -z "$GXX" && test -z "$ACE_CONFIG"; then + case "$target" in + *solaris*) + TAO_CXXFLAGS="$TAO_CXXFLAGS -features=rtti" + ;; + *) + ;; + esac + fi + ], + [ + AC_MSG_RESULT(no) + ]) + +fi dnl test -z "$ACE_CONFIG" + +dnl Check if templates require source on platform using ACE headers +AC_MSG_CHECKING(if ACE and TAO require template source) +AC_EGREP_CPP(TAO_TEMPLATES_SOURCE, + [ +#include <ace/config.h> + +#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) + TAO_TEMPLATES_SOURCE +#endif + ], + [ + tao_cv_feature_templates_require_source="yes" + AC_MSG_RESULT(yes) + ], + [ + tao_cv_feature_templates_require_source="no" + AC_MSG_RESULT(no) + ]) +AM_CONDITIONAL(TEMPLATES_REQUIRE_SOURCE, + test X$tao_cv_feature_templates_require_source = Xyes) + + +dnl Additional flags to set by the configure script + +if test -n "$GXX" && test -z "$ACE_CONFIG"; then + TAO_CXXFLAGS="$TAO_CXXFLAGS -W -Wall -Wpointer-arith" +fi + +if test -n "$GCC" && test -z "$ACE_CONFIG"; then + TAO_CFLAGS="$TAO_CFLAGS -W -Wall -Wpointer-arith" +fi + +dnl Combine package set flags with user's flags. +dnl User's flags go after package flags to allow user to override +dnl package defaults. +dnl X_CFLAGS comes from AC_PATH_XTRA. It may include, for example, +dnl additional include file paths or macros that need to be defined +dnl in order for X11 related files to be compiled properly. +CXXFLAGS="$TAO_CXXFLAGS $CXXFLAGS" +CFLAGS="$TAO_CFLAGS $CFLAGS" +CPPFLAGS="$TAO_CPPFLAGS $CPPFLAGS" +LDFLAGS="$TAO_LDFLAGS $LDFLAGS" + +dnl Prepend purify and quantify command lines if purify and quantify are +dnl enabled. Otherwise, PURELINK and PRELINK will just be "blank." +LD="$PURELINK $PRELINK $LD" +dnl LDFLAGS="$ACE_LDFLAGS $LDFLAGS" + +dnl AC_SUBST(LDFLAGS) +dnl AC_SUBST(LIBOBJS) + +dnl These definitions are expanded in the makefile and ace-config +TAO_LIBDIR='-L${libdir}' +TAO_LIBS="${LIBS}" +TAO_INCLUDEDIR='-I${includedir}' + +AC_SUBST(TAO_LIBDIR) +AC_SUBST(TAO_LIBS) +AC_SUBST(TAO_INCLUDEDIR) + +dnl Force CXXFLAGS to be substituted in Makefiles that don't "need" them. +AC_SUBST(CXXFLAGS) + +dnl +dnl SECTION 16: `AC_OUTPUT([FILE...])' +dnl +dnl +dnl We can finally create all the files listed here; Makefile is +dnl created from Makefile.in, etc. Top-level Makefiles should be +dnl created first. +AC_OUTPUT([ + Makefile + TAO_IDL/Makefile + TAO_IDL/ast/Makefile + TAO_IDL/be/Makefile + TAO_IDL/be_include/Makefile + TAO_IDL/driver/Makefile + TAO_IDL/fe/Makefile + TAO_IDL/include/Makefile + TAO_IDL/narrow/Makefile + TAO_IDL/util/Makefile + tao/Makefile + tao-config + ], + [ + echo "" + echo "Configuration of TAO is now complete." + echo "" + ]) diff --git a/TAO/examples/Buffered_AMI/client.cpp b/TAO/examples/Buffered_AMI/client.cpp index 8aad581ec55..f416910ee6b 100644 --- a/TAO/examples/Buffered_AMI/client.cpp +++ b/TAO/examples/Buffered_AMI/client.cpp @@ -61,13 +61,42 @@ public: received_all_replies = 1; } - void method_excep (AMI_testExceptionHolder *, + void method_excep (AMI_testExceptionHolder *holder, CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) - { - ACE_PRINT_EXCEPTION ((*ACE_TRY_ENV.exception ()), - "AMI exception caught:"); - } + { + ACE_TRY + { + holder->raise_method (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCH(CORBA::SystemException, ex) + { + ACE_PRINT_EXCEPTION (ex, "Reply_Handler::method_excep: "); + } + ACE_ENDTRY; + } + + void shutdown (CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) + { + } + + void shutdown_excep (AMI_testExceptionHolder *holder, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) + { + ACE_TRY + { + holder->raise_shutdown (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCH(CORBA::SystemException, ex) + { + ACE_PRINT_EXCEPTION (ex, "Reply_Handler::shutdown_excep: "); + } + ACE_ENDTRY; + } }; static int diff --git a/TAO/examples/Buffered_AMI/run_test.pl b/TAO/examples/Buffered_AMI/run_test.pl index cc4c782cf58..67d7d38fb4f 100755 --- a/TAO/examples/Buffered_AMI/run_test.pl +++ b/TAO/examples/Buffered_AMI/run_test.pl @@ -19,7 +19,7 @@ $CL = new PerlACE::Process ("client", "-k file://$iorfile -x"); $SV->Spawn (); -if (PerlACE::waitforfile_timed ($iorfile, 5) == -1) { +if (PerlACE::waitforfile_timed ($iorfile, 15) == -1) { print STDERR "ERROR: cannot find file <$iorfile>\n"; $SV->Kill (); exit 1; diff --git a/TAO/examples/Buffered_AMI/test.idl b/TAO/examples/Buffered_AMI/test.idl index cacccf61188..2a1eca586b6 100644 --- a/TAO/examples/Buffered_AMI/test.idl +++ b/TAO/examples/Buffered_AMI/test.idl @@ -7,5 +7,5 @@ interface test void method (in unsigned long request_number, out unsigned long reply_number); - oneway void shutdown (); + void shutdown (); }; diff --git a/TAO/examples/Buffered_Oneways/run_test.pl b/TAO/examples/Buffered_Oneways/run_test.pl index ff810f280c4..5d64b90f060 100755 --- a/TAO/examples/Buffered_Oneways/run_test.pl +++ b/TAO/examples/Buffered_Oneways/run_test.pl @@ -29,7 +29,7 @@ print STDERR "\nFlushing based on implicit message counts\n\n"; $CL->Arguments ("-k file://$iorfile -c 5 -b -1 -f -1 -t -1"); -$client = $CL->SpawnWaitKill (60); +$client = $CL->SpawnWaitKill (300); if ($client != 0) { print STDERR "ERROR: client returned $client\n"; @@ -40,7 +40,7 @@ print STDERR "\nFlushing based on implicit message bytes\n\n"; $CL->Arguments ("-k file://$iorfile -b 250 -c -1 -f -1 -t -1"); -$client = $CL->SpawnWaitKill (60); +$client = $CL->SpawnWaitKill (300); if ($client != 0) { print STDERR "ERROR: client returned $client\n"; @@ -51,7 +51,7 @@ print STDERR "\nFlushing based on implicit timeout\n\n"; $CL->Arguments ("-k file://$iorfile -t 5000 -b -1 -c -1 -f -1"); -$client = $CL->SpawnWaitKill (60); +$client = $CL->SpawnWaitKill (300); if ($client != 0) { print STDERR "ERROR: client returned $client\n"; @@ -62,7 +62,7 @@ print STDERR "\nExplicit queue flushing (and server shutdown)\n\n"; $CL->Arguments ("-k file://$iorfile -f 5 -b -1 -c 100 -t -1 -x"); -$client = $CL->SpawnWaitKill (60); +$client = $CL->SpawnWaitKill (300); if ($client != 0) { print STDERR "ERROR: client returned $client\n"; diff --git a/TAO/examples/PluggableUDP/DIOP/DIOP_Connection_Handler.cpp b/TAO/examples/PluggableUDP/DIOP/DIOP_Connection_Handler.cpp index 1582bccf625..8afe2b82c74 100644 --- a/TAO/examples/PluggableUDP/DIOP/DIOP_Connection_Handler.cpp +++ b/TAO/examples/PluggableUDP/DIOP/DIOP_Connection_Handler.cpp @@ -59,23 +59,7 @@ TAO_DIOP_Connection_Handler::TAO_DIOP_Connection_Handler (TAO_ORB_Core *orb_core TAO_DIOP_Connection_Handler::~TAO_DIOP_Connection_Handler (void) { - if (this->transport () != 0) { - // If the socket has not already been closed. - if (this->get_handle () != ACE_INVALID_HANDLE) - { - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (); - } - else - { - // Dequeue messages and delete message blocks. - this->transport ()->dequeue_all (); - } - } - // @@ Frank: Added from DIOP_Connect.cpp - this->handle_cleanup (); - - udp_socket_.close (); + this->udp_socket_.close (); } // DIOP Additions - Begin @@ -247,9 +231,6 @@ TAO_DIOP_Connection_Handler::handle_close (ACE_HANDLE handle, // Close the handle.. if (this->get_handle () != ACE_INVALID_HANDLE) { - // Send the buffered messages first - this->transport ()->send_buffered_messages (); - // Purge the entry too this->transport ()->mark_invalid (); @@ -278,18 +259,11 @@ int TAO_DIOP_Connection_Handler::handle_timeout (const ACE_Time_Value &, const void *) { - // This method is called when buffering timer expires. - // - ACE_Time_Value *max_wait_time = 0; - - TAO_Stub *stub = 0; - int has_timeout; - this->orb_core ()->call_timeout_hook (stub, - has_timeout, - *max_wait_time); - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (max_wait_time); + if (this->transport ()->handle_output () == -1) + { + return -1; + } return 0; } diff --git a/TAO/examples/PluggableUDP/DIOP/DIOP_Transport.cpp b/TAO/examples/PluggableUDP/DIOP/DIOP_Transport.cpp index d8fc10372d0..bed3fa5b098 100644 --- a/TAO/examples/PluggableUDP/DIOP/DIOP_Transport.cpp +++ b/TAO/examples/PluggableUDP/DIOP/DIOP_Transport.cpp @@ -1,6 +1,10 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ +#include "DIOP_Transport.h" +#include "DIOP_Connection_Handler.h" +#include "DIOP_Acceptor.h" +#include "DIOP_Profile.h" #include "tao/Acceptor_Registry.h" #include "tao/operation_details.h" #include "tao/Timeprobe.h" @@ -14,12 +18,6 @@ #include "tao/GIOP_Message_Base.h" #include "tao/GIOP_Message_Lite.h" - -#include "DIOP_Transport.h" -#include "DIOP_Connection_Handler.h" -#include "DIOP_Acceptor.h" -#include "DIOP_Profile.h" - #if !defined (__ACE_INLINE__) # include "DIOP_Transport.i" #endif /* ! __ACE_INLINE__ */ @@ -69,155 +67,17 @@ TAO_DIOP_Transport::messaging_object (void) return this->messaging_object_; } - ssize_t -TAO_DIOP_Transport::send_i (const ACE_Message_Block *message_block, - const ACE_Time_Value * /*max_wait_time*/, - size_t *bt) +TAO_DIOP_Transport::send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *max_wait_time) { - const ACE_INET_Addr &addr = this->connection_handler_->addr (); - - /*size_t temp = 0; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0;*/ - ssize_t bytes_transferred = 0; - if (bt) - { - bytes_transferred = *bt; - } - - char stack_buffer[ACE_MAX_DGRAM_SIZE]; - size_t stack_offset=0; - size_t message_length=0; - - iovec iov[IOV_MAX]; - int iovcnt = 0; - - while (message_block != 0) - { - // Our current message block chain. - const ACE_Message_Block *current_message_block = message_block; - - while (current_message_block != 0) - { - size_t current_message_block_length = - current_message_block->length (); - - message_length += current_message_block_length; - - if(message_length > ACE_MAX_DGRAM_SIZE) - { - // This is an error as we do not send more. - // Silently drop the message but log an error. - - // Pluggable_Messaging::transport_message only - // cares if it gets -1 or 0 so we can return a - // partial length and it will think all has gone - // well. - - - if (TAO_debug_level > 0) - { - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("\n\nTAO (%P|%t) ") - ACE_TEXT ("DIOP_Transport::send ") - ACE_TEXT ("Message length %d exceeds ACE_MAX_DGRAM_SIZE=%d\n"), - message_length, - ACE_MAX_DGRAM_SIZE)); - } - - return 1; // Pretend it is o.k. - // This is a problem in the message - // catalogue. - } - - // Check if this block has any data to be sent. - if (current_message_block_length > 0) - { - if(iovcnt < (IOV_MAX-1)) - { - // Collect the data in the iovec. - iov[iovcnt].iov_base = current_message_block->rd_ptr (); - iov[iovcnt].iov_len = current_message_block_length; - - // Increment iovec counter. - iovcnt++; - - // The buffer is full make a OS call. @@ TODO find a way to - // find IOV_MAX for platforms that do not define it rather - // than simply setting IOV_MAX to some arbitrary value such - // as 16. - } - else - { - // @@ John Mackenzie. If we reach IOVMAX-1 we need to pack - // the remanining blocks into the last available buffer. - - ACE_OS::memcpy(stack_buffer+stack_offset, - current_message_block->rd_ptr (), - current_message_block_length); - stack_offset += current_message_block_length; - - iovcnt = IOV_MAX; // We just stay with the last buffer. - iov[iovcnt-1].iov_base = stack_buffer; - iov[iovcnt-1].iov_len = stack_offset; - } - } - - // Select the next message block in the chain. - current_message_block = current_message_block->cont (); - } - - // Selection of the next message block chain. - message_block = message_block->next (); - } - - if (TAO_debug_level > 0) - { - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("\n\nTAO (%P|%t) ") - ACE_TEXT ("iovcnt is %d \n."),iovcnt)); - } - - // Send the buffers. + ssize_t retval = this->connection_handler_->peer ().sendv (iov, iovcnt, + max_wait_time); + if (retval > 0) + bytes_transferred = retval; - if (iovcnt != 0) - { - bytes_transferred = - this->connection_handler_->dgram ().send (iov, - iovcnt, - addr); - - if (TAO_debug_level > 0) - { - ACE_DEBUG ((LM_DEBUG, - "TAO_DIOP_Transport::send_i: sent %d bytes to %s:%d\n", - bytes_transferred, - addr.get_host_name (), - addr.get_port_number ())); - } - - // Errors. - // @@ John Mackenzie. We cannot propogate errors up in DIOP - // as it will cause transport recycle which makes no sense - // Error could be ECONNREFUSED if transport reports ICMP errors. - } - - if (bytes_transferred == -1 || bytes_transferred == 0) - { - if (TAO_debug_level > 0) - { - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("\n\nTAO (%P|%t) ") - ACE_TEXT ("DIOP_Transport::send") - ACE_TEXT (" %p\n\n"), - ACE_TEXT ("Error returned from transport:"))); - } - return 1; // Fake a good return. - } - - // Return total bytes transferred. - return bytes_transferred; + return retval; } ssize_t @@ -288,7 +148,7 @@ int TAO_DIOP_Transport::register_handler_i (void) { // @@ Michael: - // + // // We do never register register the handler with the reactor // as we never need to be informed about any incoming data, // assuming we only use one-ways. @@ -352,7 +212,7 @@ TAO_DIOP_Transport::send_message (TAO_OutputCDR &stream, // versions seem to need it though. Leaving it costs little. // This guarantees to send all data (bytes) or return an error. - ssize_t n = this->send_or_buffer (stub, + ssize_t n = this->send_message_i (stub, twoway, stream.begin (), max_wait_time); @@ -368,17 +228,6 @@ TAO_DIOP_Transport::send_message (TAO_OutputCDR &stream, return -1; } - // EOF. - if (n == 0) - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") - ACE_TEXT ("EOF, closing transport %d\n"), - this->id ())); - return -1; - } - return 1; } @@ -675,4 +524,3 @@ TAO_DIOP_Transport::transition_handler_state_i (void) { this->connection_handler_ = 0; } - diff --git a/TAO/examples/PluggableUDP/DIOP/DIOP_Transport.h b/TAO/examples/PluggableUDP/DIOP/DIOP_Transport.h index c4585141dd1..3e4abd9c43e 100644 --- a/TAO/examples/PluggableUDP/DIOP/DIOP_Transport.h +++ b/TAO/examples/PluggableUDP/DIOP/DIOP_Transport.h @@ -72,10 +72,9 @@ protected: virtual TAO_Pluggable_Messaging *messaging_object (void); /// Write the complete Message_Block chain to the connection. - virtual ssize_t send_i (const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0, - size_t *bytes_transferred = 0); - + virtual ssize_t send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *max_wait_time); /// Read len bytes from into buf. virtual ssize_t recv_i (char *buf, diff --git a/TAO/orbsvcs/FT_Service/Makefile b/TAO/orbsvcs/FT_Service/Makefile deleted file mode 100644 index 38ece35ccf7..00000000000 --- a/TAO/orbsvcs/FT_Service/Makefile +++ /dev/null @@ -1,720 +0,0 @@ -#---------------------------------------------------------------------------- -# -# $Id$ -# -#---------------------------------------------------------------------------- -ifndef TAO_ROOT - TAO_ROOT = $(ACE_ROOT)/TAO -endif # ! TAO_ROOT - -LIBNAME = libTAO_FTService -LIB = $(LIBNAME).a -SHLIB = $(LIBNAME).$(SOEXT) - -VPATH=.: - -ACE_SHLIBS = -lTAO_CosNotification -lTAO_CosNaming -lTAO_Svc_Utils -lTAO -lACE - -#---------------------------------------------------------------------------- -# Include macros and targets -#---------------------------------------------------------------------------- - -include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU -include $(TAO_ROOT)/rules.tao.GNU - -# On non-Windows environment, we should at least define -# the export_include IDL flag. -CPP_SRCS += \ - FT_CORBA_ServiceC \ - FT_CORBA_ServiceS - -FILES = $(CPP_SRCS) -DEFS = $(addsuffix .h,$(FILES)) -LSRC = $(addsuffix .cpp,$(FILES)) - -include $(ACE_ROOT)/include/makeinclude/macros.GNU -include $(ACE_ROOT)/include/makeinclude/rules.common.GNU -include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU -include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU -include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU -include $(ACE_ROOT)/include/makeinclude/rules.local.GNU - -#---------------------------------------------------------------------------- -# Local targets (and local hacks) -#---------------------------------------------------------------------------- - -LDFLAGS += -L$(TAO_ROOT)/tao -L$(TAO_ROOT)/orbsvcs/orbsvcs -CPPFLAGS += -I$(TAO_ROOT) -I$(TAO_ROOT)/orbsvcs -# DO NOT DELETE THIS LINE -- g++dep uses it. -# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. - - -.obj/FT_CORBA_ServiceC.o .obj/FT_CORBA_ServiceC.so .shobj/FT_CORBA_ServiceC.o .shobj/FT_CORBA_ServiceC.so: FT_CORBA_ServiceC.cpp FT_CORBA_ServiceC.h \ - $(ACE_ROOT)/ace/pre.h \ - $(TAO_ROOT)/tao/FT_CORBAC.h \ - $(TAO_ROOT)/tao/ftcorbafwd.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/CDR.h \ - $(TAO_ROOT)/tao/corbafwd.h \ - $(ACE_ROOT)/ace/CDR_Stream.h \ - $(ACE_ROOT)/ace/Message_Block.h \ - $(ACE_ROOT)/ace/ACE.h \ - $(ACE_ROOT)/ace/OS.h \ - $(ACE_ROOT)/ace/config-sunos5.6.h \ - $(ACE_ROOT)/ace/config-sunos5.5.h \ - $(ACE_ROOT)/ace/post.h \ - $(ACE_ROOT)/ace/ACE_export.h \ - $(ACE_ROOT)/ace/svc_export.h \ - $(ACE_ROOT)/ace/ace_wchar.h \ - $(ACE_ROOT)/ace/OS_Dirent.h \ - $(ACE_ROOT)/ace/OS_Export.h \ - $(ACE_ROOT)/ace/OS_Dirent.inl \ - $(ACE_ROOT)/ace/OS_String.h \ - $(ACE_ROOT)/ace/OS_String.inl \ - $(ACE_ROOT)/ace/OS_Memory.h \ - $(ACE_ROOT)/ace/OS_Memory.inl \ - $(ACE_ROOT)/ace/OS_TLI.h \ - $(ACE_ROOT)/ace/OS_TLI.inl \ - $(ACE_ROOT)/ace/Min_Max.h \ - $(ACE_ROOT)/ace/streams.h \ - $(ACE_ROOT)/ace/Basic_Types.h \ - $(ACE_ROOT)/ace/Basic_Types.i \ - $(ACE_ROOT)/ace/Trace.h \ - $(ACE_ROOT)/ace/OS.i \ - $(ACE_ROOT)/ace/Log_Msg.h \ - $(ACE_ROOT)/ace/Log_Record.h \ - $(ACE_ROOT)/ace/Log_Priority.h \ - $(ACE_ROOT)/ace/Log_Record.i \ - $(ACE_ROOT)/ace/ACE.i \ - $(ACE_ROOT)/ace/Malloc.h \ - $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Based_Pointer_T.h \ - $(ACE_ROOT)/ace/Based_Pointer_T.i \ - $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ - $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Synch.h \ - $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ - $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ - $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ - $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ - $(ACE_ROOT)/ace/Synch.i \ - $(ACE_ROOT)/ace/Synch_T.h \ - $(ACE_ROOT)/ace/Event_Handler.h \ - $(ACE_ROOT)/ace/Event_Handler.i \ - $(ACE_ROOT)/ace/Synch_T.i \ - $(ACE_ROOT)/ace/Thread.h \ - $(ACE_ROOT)/ace/Thread.i \ - $(ACE_ROOT)/ace/Atomic_Op.i \ - $(ACE_ROOT)/ace/Synch_T.cpp \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ - $(ACE_ROOT)/ace/Free_List.h \ - $(ACE_ROOT)/ace/Free_List.i \ - $(ACE_ROOT)/ace/Free_List.cpp \ - $(ACE_ROOT)/ace/Malloc_T.i \ - $(ACE_ROOT)/ace/Malloc_T.cpp \ - $(ACE_ROOT)/ace/Memory_Pool.h \ - $(ACE_ROOT)/ace/Signal.h \ - $(ACE_ROOT)/ace/Containers.h \ - $(ACE_ROOT)/ace/Containers.i \ - $(ACE_ROOT)/ace/Containers_T.h \ - $(ACE_ROOT)/ace/Containers_T.i \ - $(ACE_ROOT)/ace/Containers_T.cpp \ - $(ACE_ROOT)/ace/Signal.i \ - $(ACE_ROOT)/ace/Mem_Map.h \ - $(ACE_ROOT)/ace/Mem_Map.i \ - $(ACE_ROOT)/ace/Memory_Pool.i \ - $(ACE_ROOT)/ace/Message_Block.i \ - $(ACE_ROOT)/ace/Message_Block_T.h \ - $(ACE_ROOT)/ace/Message_Block_T.i \ - $(ACE_ROOT)/ace/Message_Block_T.cpp \ - $(ACE_ROOT)/ace/SString.h \ - $(ACE_ROOT)/ace/SString.i \ - $(ACE_ROOT)/ace/CDR_Stream.i \ - $(TAO_ROOT)/tao/try_macros.h \ - $(TAO_ROOT)/tao/orbconf.h \ - $(ACE_ROOT)/ace/CORBA_macros.h \ - $(TAO_ROOT)/tao/varbase.h \ - $(TAO_ROOT)/tao/TAO_Export.h \ - $(TAO_ROOT)/tao/corbafwd.i \ - $(TAO_ROOT)/tao/CDR.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ - $(TAO_ROOT)/tao/Object.h \ - $(TAO_ROOT)/tao/Object.i \ - $(TAO_ROOT)/tao/Typecode.h \ - $(TAO_ROOT)/tao/Exception.h \ - $(TAO_ROOT)/tao/Exception.i \ - $(TAO_ROOT)/tao/Typecode.i \ - $(TAO_ROOT)/tao/Any.i \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/GIOPC.h \ - $(TAO_ROOT)/tao/IOPC.h \ - $(TAO_ROOT)/tao/Sequence.h \ - $(TAO_ROOT)/tao/Managed_Types.h \ - $(TAO_ROOT)/tao/Managed_Types.i \ - $(TAO_ROOT)/tao/Sequence.i \ - $(TAO_ROOT)/tao/Sequence_T.h \ - $(TAO_ROOT)/tao/Sequence_T.i \ - $(TAO_ROOT)/tao/Sequence_T.cpp \ - $(TAO_ROOT)/tao/IOPC.i \ - $(TAO_ROOT)/tao/Object_KeyC.h \ - $(TAO_ROOT)/tao/Object_KeyC.i \ - $(TAO_ROOT)/tao/GIOPC.i \ - $(TAO_ROOT)/tao/PolicyC.h \ - $(TAO_ROOT)/tao/CurrentC.h \ - $(TAO_ROOT)/tao/CurrentC.i \ - $(TAO_ROOT)/tao/Encodable.h \ - $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/FT_CORBAC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ - $(TAO_ROOT)/tao/corba.h \ - $(TAO_ROOT)/tao/ORB.h \ - $(TAO_ROOT)/tao/IOR_LookupTable.h \ - $(ACE_ROOT)/ace/Hash_Map_Manager.h \ - $(ACE_ROOT)/ace/Functor.h \ - $(ACE_ROOT)/ace/Functor.i \ - $(ACE_ROOT)/ace/Functor_T.h \ - $(ACE_ROOT)/ace/Functor_T.i \ - $(ACE_ROOT)/ace/Functor_T.cpp \ - $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ - $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ - $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ - $(ACE_ROOT)/ace/Service_Config.h \ - $(ACE_ROOT)/ace/Service_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.i \ - $(ACE_ROOT)/ace/Service_Object.i \ - $(ACE_ROOT)/ace/Service_Config.i \ - $(ACE_ROOT)/ace/Reactor.h \ - $(ACE_ROOT)/ace/Handle_Set.h \ - $(ACE_ROOT)/ace/Handle_Set.i \ - $(ACE_ROOT)/ace/Timer_Queue.h \ - $(ACE_ROOT)/ace/Timer_Queue_T.h \ - $(ACE_ROOT)/ace/Timer_Queue_T.i \ - $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ - $(ACE_ROOT)/ace/Reactor.i \ - $(ACE_ROOT)/ace/Reactor_Impl.h \ - $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ - $(TAO_ROOT)/tao/Services.h \ - $(TAO_ROOT)/tao/Services.i \ - $(TAO_ROOT)/tao/IORManipulation.h \ - $(TAO_ROOT)/tao/LocalObject.h \ - $(TAO_ROOT)/tao/LocalObject.i \ - $(TAO_ROOT)/tao/IORC.h \ - $(TAO_ROOT)/tao/IORC.i \ - $(TAO_ROOT)/tao/PortableInterceptor.h \ - $(TAO_ROOT)/tao/Request_Info.h \ - $(TAO_ROOT)/tao/PortableInterceptorC.h \ - $(TAO_ROOT)/tao/DynamicC.h \ - $(TAO_ROOT)/tao/DynAnyC.h \ - $(TAO_ROOT)/tao/DynAnyC.i \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/ValueBase.h \ - $(TAO_ROOT)/tao/ValueBase.i \ - $(TAO_ROOT)/tao/ValueFactory.h \ - $(TAO_ROOT)/tao/ValueFactory.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/PollableC.i \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/PortableInterceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ - $(TAO_ROOT)/tao/Principal.h \ - $(TAO_ROOT)/tao/Principal.i \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/Request.i \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/POA.h \ - $(TAO_ROOT)/tao/Object_Adapter.h \ - $(TAO_ROOT)/tao/Key_Adapters.h \ - $(ACE_ROOT)/ace/Map.h \ - $(ACE_ROOT)/ace/Map_T.h \ - $(ACE_ROOT)/ace/Pair.h \ - $(ACE_ROOT)/ace/Pair_T.h \ - $(ACE_ROOT)/ace/Pair_T.i \ - $(ACE_ROOT)/ace/Pair_T.cpp \ - $(ACE_ROOT)/ace/Map_Manager.h \ - $(ACE_ROOT)/ace/Map_Manager.i \ - $(ACE_ROOT)/ace/Map_Manager.cpp \ - $(ACE_ROOT)/ace/Active_Map_Manager.h \ - $(ACE_ROOT)/ace/Active_Map_Manager.i \ - $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ - $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ - $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ - $(ACE_ROOT)/ace/Map_T.i \ - $(ACE_ROOT)/ace/Map_T.cpp \ - $(TAO_ROOT)/tao/PortableServerC.h \ - $(TAO_ROOT)/tao/PortableServerC.i \ - $(TAO_ROOT)/tao/Key_Adapters.i \ - $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ - $(TAO_ROOT)/tao/poa_macros.h \ - $(TAO_ROOT)/tao/Servant_Base.h \ - $(TAO_ROOT)/tao/Servant_Base.i \ - $(TAO_ROOT)/tao/Active_Object_Map.h \ - $(TAO_ROOT)/tao/Active_Object_Map.i \ - $(TAO_ROOT)/tao/RTCORBAC.h \ - $(TAO_ROOT)/tao/RTCORBAC.i \ - $(TAO_ROOT)/tao/Object_Adapter.i \ - $(TAO_ROOT)/tao/POAManager.h \ - $(TAO_ROOT)/tao/POAManager.i \ - $(TAO_ROOT)/tao/POA.i \ - $(TAO_ROOT)/tao/Stub.h \ - $(TAO_ROOT)/tao/Pluggable.h \ - $(ACE_ROOT)/ace/Message_Queue.h \ - $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ - $(ACE_ROOT)/ace/Message_Queue_T.h \ - $(ACE_ROOT)/ace/Message_Queue_T.i \ - $(ACE_ROOT)/ace/Message_Queue_T.cpp \ - $(ACE_ROOT)/ace/Strategies.h \ - $(ACE_ROOT)/ace/Strategies_T.h \ - $(ACE_ROOT)/ace/Synch_Options.h \ - $(ACE_ROOT)/ace/Synch_Options.i \ - $(ACE_ROOT)/ace/Thread_Manager.h \ - $(ACE_ROOT)/ace/Thread_Manager.i \ - $(ACE_ROOT)/ace/Strategies_T.i \ - $(ACE_ROOT)/ace/Strategies_T.cpp \ - $(ACE_ROOT)/ace/Service_Repository.h \ - $(ACE_ROOT)/ace/Service_Types.h \ - $(ACE_ROOT)/ace/Service_Types.i \ - $(ACE_ROOT)/ace/Service_Repository.i \ - $(ACE_ROOT)/ace/WFMO_Reactor.h \ - $(ACE_ROOT)/ace/WFMO_Reactor.i \ - $(ACE_ROOT)/ace/Strategies.i \ - $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/Profile.h \ - $(TAO_ROOT)/tao/Tagged_Components.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.i \ - $(TAO_ROOT)/tao/Tagged_Components.i \ - $(TAO_ROOT)/tao/Profile.i \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/params.h \ - $(TAO_ROOT)/tao/params.i \ - $(TAO_ROOT)/tao/ORB_Core.h \ - $(TAO_ROOT)/tao/Policy_Manager.h \ - $(TAO_ROOT)/tao/POA_CORBA.h \ - $(TAO_ROOT)/tao/DomainC.h \ - $(TAO_ROOT)/tao/DomainC.i \ - $(TAO_ROOT)/tao/Policy_Manager.i \ - $(TAO_ROOT)/tao/Resource_Factory.h \ - $(TAO_ROOT)/tao/Protocol_Factory.h \ - $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ - $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ - $(TAO_ROOT)/tao/TAO_Singleton.h \ - $(TAO_ROOT)/tao/TAO_Singleton.inl \ - $(TAO_ROOT)/tao/TAO_Singleton.cpp \ - $(TAO_ROOT)/tao/ORB_Core.i \ - $(ACE_ROOT)/ace/Dynamic_Service.h \ - $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/Operation_Table.h \ - $(TAO_ROOT)/tao/debug.h \ - $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ - $(TAO_ROOT)/tao/Invocation.h \ - $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.i \ - $(TAO_ROOT)/tao/GIOP_Message_State.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ - $(TAO_ROOT)/tao/Pluggable_Messaging.i \ - $(TAO_ROOT)/tao/GIOP_Message_State.i \ - $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.i \ - $(TAO_ROOT)/tao/TAOC.h \ - $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ - $(TAO_ROOT)/tao/Priority_Mapping.h \ - $(TAO_ROOT)/tao/Priority_Mapping.i \ - $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ - $(TAO_ROOT)/tao/TAOC.i \ - $(TAO_ROOT)/tao/operation_details.h \ - $(TAO_ROOT)/tao/target_specification.h \ - $(TAO_ROOT)/tao/target_specification.i \ - $(TAO_ROOT)/tao/operation_details.i \ - $(TAO_ROOT)/tao/Invocation.i \ - $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ - $(TAO_ROOT)/tao/DynAny_i.h \ - $(TAO_ROOT)/tao/ObjectIDList.h \ - $(TAO_ROOT)/tao/ObjectIDList.i \ - $(TAO_ROOT)/tao/WrongTransactionC.h \ - $(TAO_ROOT)/tao/InterfaceC.h \ - $(TAO_ROOT)/tao/ifrfwd.h \ - $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i \ - $(TAO_ROOT)/tao/MessagingS.h \ - $(TAO_ROOT)/tao/TimeBaseS.h \ - $(TAO_ROOT)/tao/TimeBaseS_T.h \ - $(TAO_ROOT)/tao/TimeBaseS_T.i \ - $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ - $(TAO_ROOT)/tao/TimeBaseS.i \ - $(TAO_ROOT)/tao/MessagingS_T.h \ - $(TAO_ROOT)/tao/MessagingS_T.i \ - $(TAO_ROOT)/tao/MessagingS_T.cpp \ - $(TAO_ROOT)/tao/MessagingS.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/naming_export.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotificationC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/Notify/notify_export.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotificationC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotifyFilterC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotifyCommC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosEventCommC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosEvent/event_export.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosEventCommC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotifyCommC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotifyFilterC.i \ - FT_CORBA_ServiceC.i - -.obj/FT_CORBA_ServiceS.o .obj/FT_CORBA_ServiceS.so .shobj/FT_CORBA_ServiceS.o .shobj/FT_CORBA_ServiceS.so: FT_CORBA_ServiceS.cpp FT_CORBA_ServiceS.h \ - $(ACE_ROOT)/ace/pre.h \ - $(TAO_ROOT)/tao/ftpoafwd.h \ - $(TAO_ROOT)/tao/ftcorbafwd.h \ - $(TAO_ROOT)/tao/TimeBaseC.h \ - $(TAO_ROOT)/tao/Any.h \ - $(TAO_ROOT)/tao/CDR.h \ - $(TAO_ROOT)/tao/corbafwd.h \ - $(ACE_ROOT)/ace/CDR_Stream.h \ - $(ACE_ROOT)/ace/Message_Block.h \ - $(ACE_ROOT)/ace/ACE.h \ - $(ACE_ROOT)/ace/OS.h \ - $(ACE_ROOT)/ace/config-sunos5.6.h \ - $(ACE_ROOT)/ace/config-sunos5.5.h \ - $(ACE_ROOT)/ace/post.h \ - $(ACE_ROOT)/ace/ACE_export.h \ - $(ACE_ROOT)/ace/svc_export.h \ - $(ACE_ROOT)/ace/ace_wchar.h \ - $(ACE_ROOT)/ace/OS_Dirent.h \ - $(ACE_ROOT)/ace/OS_Export.h \ - $(ACE_ROOT)/ace/OS_Dirent.inl \ - $(ACE_ROOT)/ace/OS_String.h \ - $(ACE_ROOT)/ace/OS_String.inl \ - $(ACE_ROOT)/ace/OS_Memory.h \ - $(ACE_ROOT)/ace/OS_Memory.inl \ - $(ACE_ROOT)/ace/OS_TLI.h \ - $(ACE_ROOT)/ace/OS_TLI.inl \ - $(ACE_ROOT)/ace/Min_Max.h \ - $(ACE_ROOT)/ace/streams.h \ - $(ACE_ROOT)/ace/Basic_Types.h \ - $(ACE_ROOT)/ace/Basic_Types.i \ - $(ACE_ROOT)/ace/Trace.h \ - $(ACE_ROOT)/ace/OS.i \ - $(ACE_ROOT)/ace/Log_Msg.h \ - $(ACE_ROOT)/ace/Log_Record.h \ - $(ACE_ROOT)/ace/Log_Priority.h \ - $(ACE_ROOT)/ace/Log_Record.i \ - $(ACE_ROOT)/ace/ACE.i \ - $(ACE_ROOT)/ace/Malloc.h \ - $(ACE_ROOT)/ace/Malloc_Base.h \ - $(ACE_ROOT)/ace/Based_Pointer_T.h \ - $(ACE_ROOT)/ace/Based_Pointer_T.i \ - $(ACE_ROOT)/ace/Based_Pointer_T.cpp \ - $(ACE_ROOT)/ace/Based_Pointer_Repository.h \ - $(ACE_ROOT)/ace/Singleton.h \ - $(ACE_ROOT)/ace/Synch.h \ - $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ - $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ - $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ - $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ - $(ACE_ROOT)/ace/Synch.i \ - $(ACE_ROOT)/ace/Synch_T.h \ - $(ACE_ROOT)/ace/Event_Handler.h \ - $(ACE_ROOT)/ace/Event_Handler.i \ - $(ACE_ROOT)/ace/Synch_T.i \ - $(ACE_ROOT)/ace/Thread.h \ - $(ACE_ROOT)/ace/Thread.i \ - $(ACE_ROOT)/ace/Atomic_Op.i \ - $(ACE_ROOT)/ace/Synch_T.cpp \ - $(ACE_ROOT)/ace/Singleton.i \ - $(ACE_ROOT)/ace/Singleton.cpp \ - $(ACE_ROOT)/ace/Object_Manager.h \ - $(ACE_ROOT)/ace/Object_Manager.i \ - $(ACE_ROOT)/ace/Managed_Object.h \ - $(ACE_ROOT)/ace/Managed_Object.i \ - $(ACE_ROOT)/ace/Managed_Object.cpp \ - $(ACE_ROOT)/ace/Malloc.i \ - $(ACE_ROOT)/ace/Malloc_T.h \ - $(ACE_ROOT)/ace/Free_List.h \ - $(ACE_ROOT)/ace/Free_List.i \ - $(ACE_ROOT)/ace/Free_List.cpp \ - $(ACE_ROOT)/ace/Malloc_T.i \ - $(ACE_ROOT)/ace/Malloc_T.cpp \ - $(ACE_ROOT)/ace/Memory_Pool.h \ - $(ACE_ROOT)/ace/Signal.h \ - $(ACE_ROOT)/ace/Containers.h \ - $(ACE_ROOT)/ace/Containers.i \ - $(ACE_ROOT)/ace/Containers_T.h \ - $(ACE_ROOT)/ace/Containers_T.i \ - $(ACE_ROOT)/ace/Containers_T.cpp \ - $(ACE_ROOT)/ace/Signal.i \ - $(ACE_ROOT)/ace/Mem_Map.h \ - $(ACE_ROOT)/ace/Mem_Map.i \ - $(ACE_ROOT)/ace/Memory_Pool.i \ - $(ACE_ROOT)/ace/Message_Block.i \ - $(ACE_ROOT)/ace/Message_Block_T.h \ - $(ACE_ROOT)/ace/Message_Block_T.i \ - $(ACE_ROOT)/ace/Message_Block_T.cpp \ - $(ACE_ROOT)/ace/SString.h \ - $(ACE_ROOT)/ace/SString.i \ - $(ACE_ROOT)/ace/CDR_Stream.i \ - $(TAO_ROOT)/tao/try_macros.h \ - $(TAO_ROOT)/tao/orbconf.h \ - $(ACE_ROOT)/ace/CORBA_macros.h \ - $(TAO_ROOT)/tao/varbase.h \ - $(TAO_ROOT)/tao/TAO_Export.h \ - $(TAO_ROOT)/tao/corbafwd.i \ - $(TAO_ROOT)/tao/CDR.i \ - $(TAO_ROOT)/tao/Environment.h \ - $(TAO_ROOT)/tao/Environment.i \ - $(TAO_ROOT)/tao/Object.h \ - $(TAO_ROOT)/tao/Object.i \ - $(TAO_ROOT)/tao/Typecode.h \ - $(TAO_ROOT)/tao/Exception.h \ - $(TAO_ROOT)/tao/Exception.i \ - $(TAO_ROOT)/tao/Typecode.i \ - $(TAO_ROOT)/tao/Any.i \ - $(TAO_ROOT)/tao/TimeBaseC.i \ - $(TAO_ROOT)/tao/FT_CORBAS.h \ - $(TAO_ROOT)/tao/FT_CORBAC.h \ - $(TAO_ROOT)/tao/GIOPC.h \ - $(TAO_ROOT)/tao/IOPC.h \ - $(TAO_ROOT)/tao/Sequence.h \ - $(TAO_ROOT)/tao/Managed_Types.h \ - $(TAO_ROOT)/tao/Managed_Types.i \ - $(TAO_ROOT)/tao/Sequence.i \ - $(TAO_ROOT)/tao/Sequence_T.h \ - $(TAO_ROOT)/tao/Sequence_T.i \ - $(TAO_ROOT)/tao/Sequence_T.cpp \ - $(TAO_ROOT)/tao/IOPC.i \ - $(TAO_ROOT)/tao/Object_KeyC.h \ - $(TAO_ROOT)/tao/Object_KeyC.i \ - $(TAO_ROOT)/tao/GIOPC.i \ - $(TAO_ROOT)/tao/PolicyC.h \ - $(TAO_ROOT)/tao/CurrentC.h \ - $(TAO_ROOT)/tao/CurrentC.i \ - $(TAO_ROOT)/tao/Encodable.h \ - $(TAO_ROOT)/tao/PolicyC.i \ - $(TAO_ROOT)/tao/FT_CORBAC.i \ - $(TAO_ROOT)/tao/POA_CORBA.h \ - $(TAO_ROOT)/tao/DynAnyC.h \ - $(TAO_ROOT)/tao/DynAnyC.i \ - $(TAO_ROOT)/tao/DomainC.h \ - $(TAO_ROOT)/tao/DomainC.i \ - $(TAO_ROOT)/tao/Servant_Base.h \ - $(TAO_ROOT)/tao/PortableServerC.h \ - $(TAO_ROOT)/tao/PortableServerC.i \ - $(TAO_ROOT)/tao/Servant_Base.i \ - $(TAO_ROOT)/tao/FT_CORBAS.i \ - FT_CORBA_ServiceC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ - $(TAO_ROOT)/tao/corba.h \ - $(TAO_ROOT)/tao/ORB.h \ - $(TAO_ROOT)/tao/IOR_LookupTable.h \ - $(ACE_ROOT)/ace/Hash_Map_Manager.h \ - $(ACE_ROOT)/ace/Functor.h \ - $(ACE_ROOT)/ace/Functor.i \ - $(ACE_ROOT)/ace/Functor_T.h \ - $(ACE_ROOT)/ace/Functor_T.i \ - $(ACE_ROOT)/ace/Functor_T.cpp \ - $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ - $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ - $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ - $(ACE_ROOT)/ace/Service_Config.h \ - $(ACE_ROOT)/ace/Service_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.h \ - $(ACE_ROOT)/ace/Shared_Object.i \ - $(ACE_ROOT)/ace/Service_Object.i \ - $(ACE_ROOT)/ace/Service_Config.i \ - $(ACE_ROOT)/ace/Reactor.h \ - $(ACE_ROOT)/ace/Handle_Set.h \ - $(ACE_ROOT)/ace/Handle_Set.i \ - $(ACE_ROOT)/ace/Timer_Queue.h \ - $(ACE_ROOT)/ace/Timer_Queue_T.h \ - $(ACE_ROOT)/ace/Timer_Queue_T.i \ - $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ - $(ACE_ROOT)/ace/Reactor.i \ - $(ACE_ROOT)/ace/Reactor_Impl.h \ - $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ - $(TAO_ROOT)/tao/Services.h \ - $(TAO_ROOT)/tao/Services.i \ - $(TAO_ROOT)/tao/IORManipulation.h \ - $(TAO_ROOT)/tao/LocalObject.h \ - $(TAO_ROOT)/tao/LocalObject.i \ - $(TAO_ROOT)/tao/IORC.h \ - $(TAO_ROOT)/tao/IORC.i \ - $(TAO_ROOT)/tao/PortableInterceptor.h \ - $(TAO_ROOT)/tao/Request_Info.h \ - $(TAO_ROOT)/tao/PortableInterceptorC.h \ - $(TAO_ROOT)/tao/DynamicC.h \ - $(TAO_ROOT)/tao/MessagingC.h \ - $(TAO_ROOT)/tao/ValueBase.h \ - $(TAO_ROOT)/tao/ValueBase.i \ - $(TAO_ROOT)/tao/ValueFactory.h \ - $(TAO_ROOT)/tao/ValueFactory.i \ - $(TAO_ROOT)/tao/PollableC.h \ - $(TAO_ROOT)/tao/PollableC.i \ - $(TAO_ROOT)/tao/MessagingC.i \ - $(TAO_ROOT)/tao/PortableInterceptor.i \ - $(TAO_ROOT)/tao/ORB.i \ - $(TAO_ROOT)/tao/NVList.h \ - $(TAO_ROOT)/tao/NVList.i \ - $(TAO_ROOT)/tao/Principal.h \ - $(TAO_ROOT)/tao/Principal.i \ - $(TAO_ROOT)/tao/Request.h \ - $(TAO_ROOT)/tao/Context.h \ - $(TAO_ROOT)/tao/Context.i \ - $(TAO_ROOT)/tao/Request.i \ - $(TAO_ROOT)/tao/Server_Request.h \ - $(TAO_ROOT)/tao/Server_Request.i \ - $(TAO_ROOT)/tao/POA.h \ - $(TAO_ROOT)/tao/Object_Adapter.h \ - $(TAO_ROOT)/tao/Key_Adapters.h \ - $(ACE_ROOT)/ace/Map.h \ - $(ACE_ROOT)/ace/Map_T.h \ - $(ACE_ROOT)/ace/Pair.h \ - $(ACE_ROOT)/ace/Pair_T.h \ - $(ACE_ROOT)/ace/Pair_T.i \ - $(ACE_ROOT)/ace/Pair_T.cpp \ - $(ACE_ROOT)/ace/Map_Manager.h \ - $(ACE_ROOT)/ace/Map_Manager.i \ - $(ACE_ROOT)/ace/Map_Manager.cpp \ - $(ACE_ROOT)/ace/Active_Map_Manager.h \ - $(ACE_ROOT)/ace/Active_Map_Manager.i \ - $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ - $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ - $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ - $(ACE_ROOT)/ace/Map_T.i \ - $(ACE_ROOT)/ace/Map_T.cpp \ - $(TAO_ROOT)/tao/Key_Adapters.i \ - $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ - $(TAO_ROOT)/tao/poa_macros.h \ - $(TAO_ROOT)/tao/Active_Object_Map.h \ - $(TAO_ROOT)/tao/Active_Object_Map.i \ - $(TAO_ROOT)/tao/RTCORBAC.h \ - $(TAO_ROOT)/tao/RTCORBAC.i \ - $(TAO_ROOT)/tao/Object_Adapter.i \ - $(TAO_ROOT)/tao/POAManager.h \ - $(TAO_ROOT)/tao/POAManager.i \ - $(TAO_ROOT)/tao/POA.i \ - $(TAO_ROOT)/tao/Stub.h \ - $(TAO_ROOT)/tao/Pluggable.h \ - $(ACE_ROOT)/ace/Message_Queue.h \ - $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ - $(ACE_ROOT)/ace/Message_Queue_T.h \ - $(ACE_ROOT)/ace/Message_Queue_T.i \ - $(ACE_ROOT)/ace/Message_Queue_T.cpp \ - $(ACE_ROOT)/ace/Strategies.h \ - $(ACE_ROOT)/ace/Strategies_T.h \ - $(ACE_ROOT)/ace/Synch_Options.h \ - $(ACE_ROOT)/ace/Synch_Options.i \ - $(ACE_ROOT)/ace/Thread_Manager.h \ - $(ACE_ROOT)/ace/Thread_Manager.i \ - $(ACE_ROOT)/ace/Strategies_T.i \ - $(ACE_ROOT)/ace/Strategies_T.cpp \ - $(ACE_ROOT)/ace/Service_Repository.h \ - $(ACE_ROOT)/ace/Service_Types.h \ - $(ACE_ROOT)/ace/Service_Types.i \ - $(ACE_ROOT)/ace/Service_Repository.i \ - $(ACE_ROOT)/ace/WFMO_Reactor.h \ - $(ACE_ROOT)/ace/WFMO_Reactor.i \ - $(ACE_ROOT)/ace/Strategies.i \ - $(ACE_ROOT)/ace/Message_Queue.i \ - $(TAO_ROOT)/tao/Pluggable.i \ - $(TAO_ROOT)/tao/MProfile.h \ - $(TAO_ROOT)/tao/Profile.h \ - $(TAO_ROOT)/tao/Tagged_Components.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.h \ - $(TAO_ROOT)/tao/CONV_FRAMEC.i \ - $(TAO_ROOT)/tao/Tagged_Components.i \ - $(TAO_ROOT)/tao/Profile.i \ - $(TAO_ROOT)/tao/MProfile.i \ - $(TAO_ROOT)/tao/Stub.i \ - $(TAO_ROOT)/tao/params.h \ - $(TAO_ROOT)/tao/params.i \ - $(TAO_ROOT)/tao/ORB_Core.h \ - $(TAO_ROOT)/tao/Policy_Manager.h \ - $(TAO_ROOT)/tao/Policy_Manager.i \ - $(TAO_ROOT)/tao/Resource_Factory.h \ - $(TAO_ROOT)/tao/Protocol_Factory.h \ - $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ - $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ - $(TAO_ROOT)/tao/TAO_Singleton.h \ - $(TAO_ROOT)/tao/TAO_Singleton.inl \ - $(TAO_ROOT)/tao/TAO_Singleton.cpp \ - $(TAO_ROOT)/tao/ORB_Core.i \ - $(ACE_ROOT)/ace/Dynamic_Service.h \ - $(ACE_ROOT)/ace/Dynamic_Service.cpp \ - $(TAO_ROOT)/tao/Operation_Table.h \ - $(TAO_ROOT)/tao/debug.h \ - $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ - $(TAO_ROOT)/tao/Invocation.h \ - $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.h \ - $(TAO_ROOT)/tao/Reply_Dispatcher.i \ - $(TAO_ROOT)/tao/GIOP_Message_State.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.h \ - $(TAO_ROOT)/tao/Pluggable_Messaging_Utils.i \ - $(TAO_ROOT)/tao/Pluggable_Messaging.i \ - $(TAO_ROOT)/tao/GIOP_Message_State.i \ - $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.i \ - $(TAO_ROOT)/tao/TAOC.h \ - $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ - $(TAO_ROOT)/tao/Priority_Mapping.h \ - $(TAO_ROOT)/tao/Priority_Mapping.i \ - $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ - $(TAO_ROOT)/tao/TAOC.i \ - $(TAO_ROOT)/tao/operation_details.h \ - $(TAO_ROOT)/tao/target_specification.h \ - $(TAO_ROOT)/tao/target_specification.i \ - $(TAO_ROOT)/tao/operation_details.i \ - $(TAO_ROOT)/tao/Invocation.i \ - $(TAO_ROOT)/tao/InconsistentTypeCodeC.h \ - $(TAO_ROOT)/tao/DynAny_i.h \ - $(TAO_ROOT)/tao/ObjectIDList.h \ - $(TAO_ROOT)/tao/ObjectIDList.i \ - $(TAO_ROOT)/tao/WrongTransactionC.h \ - $(TAO_ROOT)/tao/InterfaceC.h \ - $(TAO_ROOT)/tao/ifrfwd.h \ - $(TAO_ROOT)/tao/BoundsC.h \ - $(TAO_ROOT)/tao/BoundsC.i \ - $(TAO_ROOT)/tao/MessagingS.h \ - $(TAO_ROOT)/tao/TimeBaseS.h \ - $(TAO_ROOT)/tao/TimeBaseS_T.h \ - $(TAO_ROOT)/tao/TimeBaseS_T.i \ - $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ - $(TAO_ROOT)/tao/TimeBaseS.i \ - $(TAO_ROOT)/tao/MessagingS_T.h \ - $(TAO_ROOT)/tao/MessagingS_T.i \ - $(TAO_ROOT)/tao/MessagingS_T.cpp \ - $(TAO_ROOT)/tao/MessagingS.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/naming_export.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotificationC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/Notify/notify_export.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotificationC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotifyFilterC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotifyCommC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosEventCommC.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosEvent/event_export.h \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosEventCommC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotifyCommC.i \ - $(TAO_ROOT)/orbsvcs/orbsvcs/CosNotifyFilterC.i \ - FT_CORBA_ServiceC.i FT_CORBA_ServiceS.i - -# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/orbsvcs/orbsvcs/AVStreams_Full.idl b/TAO/orbsvcs/orbsvcs/AVStreams_Full.idl deleted file mode 100644 index 2f04c91261e..00000000000 --- a/TAO/orbsvcs/orbsvcs/AVStreams_Full.idl +++ /dev/null @@ -1,252 +0,0 @@ -// $Id$ - -// IDL for Control and Management of Audio/Video Streams -// Revised Submission - -// Additional IDL for full profile -#include "AVStreams.idl" - -#pragma prefix "omg.org" - -module AVStreams_Full -{ - exception protocolNotSupported{}; - exception formatNotSupported{}; - exception formatMismatch{}; - exception FEPMismatch{}; - exception alreadyConnected{}; - exception invalidSettings{string settings;}; - exception notConnected{}; - exception deviceQosMismatch{}; - exception failedToConnect{string reason;}; - exception failedToListen{string reason;}; - - - interface FlowProducer; - interface FlowConsumer; - interface FlowEndPoint; - interface FDev; - - interface FlowConnection : PropertyService::PropertySet - { - void stop(); - void start(); - void destroy(); - - boolean modify_QoS( - - inout AVStreams::QoS new_qos) - raises (AVStreams::QoSRequestFailed); - - boolean use_flow_protocol( - in string fp_name, - in any fp_settings) - raises (AVStreams::FPError, AVStreams::notSupported); - - oneway void push_event(in AVStreams::streamEvent the_event); - - boolean connect_devs(in FDev a_party, in FDev b_party, - inout AVStreams::QoS the_qos) - raises (AVStreams::streamOpFailed, - AVStreams::streamOpDenied, - AVStreams::QoSRequestFailed); - - boolean connect( - in FlowProducer flow_producer, - in FlowConsumer flow_consumer, - inout AVStreams::QoS the_qos) - raises (formatMismatch, FEPMismatch, alreadyConnected); - - boolean disconnect(); - - // The notSupported exception is raised where - // flow cannot have multiple producers - boolean add_producer(in FlowProducer flow_producer, - inout AVStreams::QoS the_qos) - raises (alreadyConnected, AVStreams::notSupported); - - boolean add_consumer(in FlowConsumer flow_consumer, - inout AVStreams::QoS the_qos) - raises (alreadyConnected); - - boolean drop(in FlowEndPoint target) - raises (notConnected); - }; - - interface FlowEndPoint : PropertyService::PropertySet - { - boolean lock(); - void unlock(); - - void stop(); - void start(); - void destroy(); - - // Default is a nil object reference - attribute AVStreams::StreamEndPoint related_sep; - attribute FlowConnection related_flow_connection; - - FlowEndPoint get_connected_fep() - raises (notConnected, - AVStreams::notSupported); - - // syntax of fp_name is <flowProtocol> - boolean use_flow_protocol(in string fp_name, - in any fp_settings) - raises (AVStreams::FPError, AVStreams::notSupported); - - // set_format() initializes 'format' - // as current media format e.g. MPEG. - void set_format(in string format) - raises (AVStreams::notSupported); - - void set_dev_params( - in PropertyService::Properties new_settings) - raises (PropertyService::PropertyException, - AVStreams::streamOpFailed); - - void set_protocol_restriction(in AVStreams::protocolSpec - the_spec) - raises (AVStreams::notSupported); - - boolean is_fep_compatible(in FlowEndPoint fep) - raises (formatMismatch, deviceQosMismatch); - - boolean set_peer( - in FlowConnection the_fc, - - in FlowEndPoint the_peer_fep, - inout AVStreams::QoS the_qos) - raises (AVStreams::QoSRequestFailed, - AVStreams::streamOpFailed); - - boolean set_Mcast_peer( - in FlowConnection the_fc, - in AVStreams::MCastConfigIf a_mcastconfigif, - inout AVStreams::QoS the_qos) - raises (AVStreams::QoSRequestFailed); - - }; - - interface FlowProducer : FlowEndPoint - { - boolean connect_to_peer(inout AVStreams::QoS the_qos, - in string address, - - in string use_flow_protocol) // syntax <flowProtocol> - raises(failedToConnect, - AVStreams::FPError, AVStreams::QoSRequestFailed); - - string connect_mcast(inout AVStreams::QoS the_qos, - out boolean is_met, - in string address, - in string use_flow_protocol) - raises (failedToConnect, - AVStreams::notSupported, - AVStreams::FPError, - AVStreams::QoSRequestFailed); - - string get_rev_channel(in string pcol_name); - - void set_key(in AVStreams::key the_key); - void set_source_id(in long source_id); - }; - - interface FlowConsumer : FlowEndPoint - { - - - // Needs to know its peer to choose its protocol correctly - // Also to ask for a reverse channel for credit-based flow - // control, if one is required - string go_to_listen( - inout AVStreams::QoS the_qos, - in boolean is_mcast, - in FlowProducer peer, - inout string flowProtocol)// syntax <flowProtocol> - raises(failedToListen, AVStreams::FPError, - AVStreams::QoSRequestFailed); - }; - - interface FDev : PropertyService::PropertySet { - FlowProducer create_producer( - in FlowConnection the_requester, - inout AVStreams::QoS the_qos, - out boolean met_qos, - inout string named_fdev) - raises(AVStreams::streamOpFailed, - AVStreams::streamOpDenied, - AVStreams::notSupported, - AVStreams::QoSRequestFailed); - - FlowConsumer create_consumer( - in FlowConnection the_requester, - inout AVStreams::QoS the_qos, - out boolean met_qos, - inout string named_fdev) - raises(AVStreams::streamOpFailed, - AVStreams::streamOpDenied, - AVStreams::notSupported, - AVStreams::QoSRequestFailed); - - FlowConnection bind(in FDev peer_device, - inout AVStreams::QoS the_qos, - out boolean is_met) - raises (AVStreams::streamOpFailed, - AVStreams::QoSRequestFailed); - - FlowConnection bind_mcast(in FDev first_peer, - inout AVStreams::QoS the_qos, - out boolean is_met) - raises (AVStreams::streamOpFailed, - AVStreams::QoSRequestFailed); - - void destroy(in FlowEndPoint the_ep, in string fdev_name) - // ie FDev not found - raises (AVStreams::notSupported); - }; - - enum PositionOrigin { - AbsolutePosition, RelativePosition, ModuloPosition - }; - - enum PositionKey { - ByteCount, SampleCount, MediaTime - }; - - struct Position { - PositionOrigin origin; - PositionKey key; - long value; - }; - - exception PostionKeyNotSupported { PositionKey key;}; - exception InvalidPosition { PositionKey key;}; - - // MediaControl interface is similar to - // ControlledStream interface in MSS. - // It can be inherited by flow endpoints or - // FlowConnection interfaces. - interface MediaControl{ - - exception PostionKeyNotSupported { PositionKey key;}; - - Position get_media_position( - in PositionOrigin an_origin, - in PositionKey a_key) - raises (PostionKeyNotSupported); - - void set_media_position(in Position a_position) - raises (PostionKeyNotSupported, InvalidPosition); - - void start(in Position a_position) - raises(InvalidPosition); - void pause(in Position a_position) - raises(InvalidPosition); - void resume(in Position a_position) - raises(InvalidPosition); - void stop(in Position a_position) - raises(InvalidPosition); - }; -}; - diff --git a/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.cpp b/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.cpp index 4f1a17f3cb8..964c9cd2b22 100644 --- a/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.cpp +++ b/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.cpp @@ -19,10 +19,7 @@ # include "SSLIOP_Connection_Handler.i" #endif /* ! __ACE_INLINE__ */ -ACE_RCSID (TAO_SSLIOP, - SSLIOP_Connection_Handler, - "$Id$") - +ACE_RCSID (TAO_SSLIOP, SSLIOP_Connection_Handler, "$Id$") // **************************************************************** @@ -66,27 +63,10 @@ TAO_SSLIOP_Connection_Handler::TAO_SSLIOP_Connection_Handler ( } -TAO_SSLIOP_Connection_Handler:: -~TAO_SSLIOP_Connection_Handler (void) +TAO_SSLIOP_Connection_Handler::~TAO_SSLIOP_Connection_Handler (void) { - if (this->transport () != 0) - { - // If the socket has not already been closed. - if (this->get_handle () != ACE_INVALID_HANDLE) - { - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (); - } - else - { - // Dequeue messages and delete message blocks. - this->transport ()->dequeue_all (); - } - } } - - int TAO_SSLIOP_Connection_Handler::open (void *) { @@ -220,9 +200,6 @@ TAO_SSLIOP_Connection_Handler::handle_close (ACE_HANDLE handle, // Close the handle.. if (this->get_handle () != ACE_INVALID_HANDLE) { - // Send the buffered messages first - this->transport ()->send_buffered_messages (); - // Purge the entry too this->transport ()->mark_invalid (); @@ -252,23 +229,20 @@ int TAO_SSLIOP_Connection_Handler::handle_timeout (const ACE_Time_Value &, const void *) { - // This method is called when buffering timer expires. - // - ACE_Time_Value *max_wait_time = 0; - - TAO_Stub *stub = 0; - int has_timeout; - this->orb_core ()->call_timeout_hook (stub, - has_timeout, - *max_wait_time); - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (max_wait_time); + if (this->transport ()->handle_output () == -1) + return -1; return 0; } int +TAO_IIOP_Connection_Handler::handle_output (ACE_HANDLE) +{ + return this->transport ()->handle_output (); +} + +int TAO_SSLIOP_Connection_Handler::add_transport_to_cache (void) { ACE_INET_Addr addr; diff --git a/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.h b/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.h index 0f2c06c261c..aaeab6f4a24 100644 --- a/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.h +++ b/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Connection_Handler.h @@ -101,6 +101,9 @@ public: virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0); + /// Documented in ACE_Event_Handler + virtual int handle_output (ACE_HANDLE); + /// Add ourselves to Cache. int add_transport_to_cache (void); diff --git a/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.cpp b/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.cpp index ec367a37450..d69fb1b06a1 100644 --- a/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.cpp +++ b/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.cpp @@ -3,12 +3,9 @@ // $Id$ #include "SSLIOP_Transport.h" - #include "tao/debug.h" -ACE_RCSID (TAO_SSLIOP, - SSLIOP_Transport, - "$Id$") +ACE_RCSID (TAO_SSLIOP, SSLIOP_Transport, "$Id$") #include "SSLIOP_Connection_Handler.h" #include "SSLIOP_Profile.h" @@ -72,74 +69,16 @@ TAO_SSLIOP_Transport::messaging_object (void) ssize_t -TAO_SSLIOP_Transport::send_i (const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time, - size_t *bt) +TAO_SSLIOP_Transport::send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *max_wait_time) { - // @@ This code should be refactored into ACE.cpp or something - // similar! - - // For the most part this was copied from GIOP::send_request and - // friends. - - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - - iovec iov[IOV_MAX]; - int iovcnt = 0; - ssize_t n = 0; - - for (const ACE_Message_Block *i = message_block; - i != 0; - i = i->cont ()) - { - // Make sure there is something to send! - if (i->length () > 0) - { - iov[iovcnt].iov_base = i->rd_ptr (); - iov[iovcnt].iov_len = i->length (); - iovcnt++; - - // The buffer is full make a OS call. @@ TODO this should - // be optimized on a per-platform basis, for instance, some - // platforms do not implement writev() there we should copy - // the data into a buffer and call send_n(). In other cases - // there may be some limits on the size of the iovec, there - // we should set IOV_MAX to that limit. - if (iovcnt == IOV_MAX) - { - if (max_wait_time == 0) - n = this->connection_handler_->peer ().sendv_n (iov, - iovcnt); - else - // @@ No timeouts!!! - n = this->connection_handler_->peer ().sendv_n (iov, - iovcnt /*, - max_wait_time */); - - if (n == 0 || - n == -1) - return n; - - bytes_transferred += n; - iovcnt = 0; - } - } - } - - // Check for remaining buffers to be sent! - if (iovcnt != 0) - { - n = this->connection_handler_->peer ().sendv_n (iov, - iovcnt); - if (n == 0 || - n == -1) - return n; - - bytes_transferred += n; - } + ssize_t retval = this->connection_handler_->peer ().send (iov, iovcnt, + max_wait_time); + if (retval > 0) + bytes_transferred = retval; - return bytes_transferred; + return retval; } ssize_t @@ -191,6 +130,21 @@ TAO_SSLIOP_Transport::read_process_message (ACE_Time_Value *max_wait_time, int TAO_SSLIOP_Transport::register_handler_i (void) { + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - IIOP_Transport::register_handler %d\n", + this->id ())); + } + if (this->connection_handler_->is_registered ()) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - IIOP_Transport::register_handler %d" + ", already registered\n", + this->id ())); + return 0; + } + // @@ It seems like this method should go away, the right reactor is // picked at object creation time. ACE_Reactor *r = this->orb_core_->reactor (); @@ -244,7 +198,7 @@ TAO_SSLIOP_Transport::send_message (TAO_OutputCDR &stream, // versions seem to need it though. Leaving it costs little. // This guarantees to send all data (bytes) or return an error. - ssize_t n = this->send_or_buffer (stub, + ssize_t n = this->send_message_i (stub, twoway, stream.begin (), max_wait_time); @@ -260,17 +214,6 @@ TAO_SSLIOP_Transport::send_message (TAO_OutputCDR &stream, return -1; } - // EOF. - if (n == 0) - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") - ACE_TEXT ("EOF, closing transport %d\n"), - this->id ())); - return -1; - } - return 1; } diff --git a/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.h b/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.h index 8d82a45c26f..e3c631aa4b1 100644 --- a/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.h +++ b/TAO/orbsvcs/orbsvcs/SSLIOP/SSLIOP_Transport.h @@ -83,9 +83,9 @@ protected: virtual TAO_Pluggable_Messaging *messaging_object (void); /// Write the complete Message_Block chain to the connection. - virtual ssize_t send_i (const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0, - size_t *bytes_transferred = 0); + virtual ssize_t send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *timeout = 0); /// Read len bytes from into buf. virtual ssize_t recv_i (char *buf, diff --git a/TAO/orbsvcs/tests/Security/RejectInsecure/authorization_test_i.cpp b/TAO/orbsvcs/tests/Security/RejectInsecure/authorization_test_i.cpp deleted file mode 100644 index d0ab49a1939..00000000000 --- a/TAO/orbsvcs/tests/Security/RejectInsecure/authorization_test_i.cpp +++ /dev/null @@ -1,23 +0,0 @@ -// $Id$ - -#include "authorization_test_i.h" - -#if !defined(__ACE_INLINE__) -#include "authorization_test_i.i" -#endif /* __ACE_INLINE__ */ - -ACE_RCSID(Authorize, authorization_test_i, "$Id$") - -CORBA::Boolean -Authorization_Server_i::check_access (CORBA::Environment &) - ACE_THROW_SPEC ((CORBA::SystemException)) -{ - return 0; -} - -void -Authorization_Server_i::shutdown (CORBA::Environment&) - ACE_THROW_SPEC ((CORBA::SystemException)) -{ - this->orb_->shutdown (0); -} diff --git a/TAO/performance-tests/Latency/client.conf b/TAO/performance-tests/Latency/client.conf index 1396ec82df2..caebbf11fe5 100644 --- a/TAO/performance-tests/Latency/client.conf +++ b/TAO/performance-tests/Latency/client.conf @@ -1,4 +1,4 @@ # $Id$ # -static Advanced_Resource_Factory "-ORBReactorType select_mt" +static Advanced_Resource_Factory "-ORBReactorType select_mt -ORBFlushingStrategy blocking" static Client_Strategy_Factory "-ORBclientconnectionhandler RW" diff --git a/TAO/performance-tests/Latency/st_client.cpp b/TAO/performance-tests/Latency/st_client.cpp index ae992702e84..830d22f31cb 100644 --- a/TAO/performance-tests/Latency/st_client.cpp +++ b/TAO/performance-tests/Latency/st_client.cpp @@ -166,11 +166,11 @@ main (int argc, char *argv[]) if (TAO_debug_level > 0 && i % 100 == 0) ACE_DEBUG ((LM_DEBUG, "(%P|%t) iteration = %d\n", i)); - if (period != -1) - { - ACE_Time_Value tv (0, period * 1000); - ACE_OS::sleep (tv); - } + if (period != -1) + { + ACE_Time_Value tv (0, period * 1000); + ACE_OS::sleep (tv); + } } #if defined (USING_QUANTIFY) @@ -205,6 +205,9 @@ main (int argc, char *argv[]) server->shutdown (ACE_TRY_ENV); ACE_TRY_CHECK; } + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; } ACE_CATCHANY { diff --git a/TAO/tao/Asynch_Queued_Message.cpp b/TAO/tao/Asynch_Queued_Message.cpp new file mode 100644 index 00000000000..b848b178a97 --- /dev/null +++ b/TAO/tao/Asynch_Queued_Message.cpp @@ -0,0 +1,77 @@ +// -*- C++ -*- +// $Id$ + +#include "Asynch_Queued_Message.h" + +ACE_RCSID(tao, Asynch_Queued_Message, "$Id$") + +TAO_Asynch_Queued_Message:: + TAO_Asynch_Queued_Message (const ACE_Message_Block *contents) + : offset_ (0) +{ + this->size_ = contents->total_length (); + // @@ Use a pool for these guys!! + ACE_NEW (this->buffer_, char[this->size_]); + + size_t copy_offset = 0; + for (const ACE_Message_Block *i = contents; + i != 0; + i = i->cont ()) + { + ACE_OS::memcpy (this->buffer_ + copy_offset, + i->rd_ptr (), + i->length ()); + copy_offset += i->length (); + } +} + +TAO_Asynch_Queued_Message::~TAO_Asynch_Queued_Message (void) +{ + // @@ Use a pool for these guys! + delete[] this->buffer_; +} + +size_t +TAO_Asynch_Queued_Message::message_length (void) const +{ + return this->size_ - this->offset_; +} + +int +TAO_Asynch_Queued_Message::all_data_sent (void) const +{ + return this->size_ == this->offset_; +} + +void +TAO_Asynch_Queued_Message::fill_iov (int iovcnt_max, + int &iovcnt, + iovec iov[]) const +{ + ACE_ASSERT (iovcnt_max > iovcnt); + + iov[iovcnt].iov_base = this->buffer_ + this->offset_; + iov[iovcnt].iov_len = this->size_ - this->offset_; + iovcnt++; +} + +void +TAO_Asynch_Queued_Message::bytes_transferred (size_t &byte_count) +{ + size_t remaining_bytes = this->size_ - this->offset_; + if (byte_count > remaining_bytes) + { + this->offset_ = this->size_; + byte_count -= remaining_bytes; + return; + } + this->offset_ += byte_count; + byte_count = 0; +} + +void +TAO_Asynch_Queued_Message::destroy (void) +{ + // @@ Maybe it comes from a pool, we should do something about it. + delete this; +} diff --git a/TAO/tao/Asynch_Queued_Message.h b/TAO/tao/Asynch_Queued_Message.h new file mode 100644 index 00000000000..dbb4ca38bb0 --- /dev/null +++ b/TAO/tao/Asynch_Queued_Message.h @@ -0,0 +1,73 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Asynch_Queued_Message.h + * + * $Id$ + * + * @author Carlos O'Ryan <coryan@uci.edu> + */ +//============================================================================= + +#ifndef TAO_ASYNCH_QUEUED_MESSAGE_H +#define TAO_ASYNCH_QUEUED_MESSAGE_H +#include "ace/pre.h" + +#include "Queued_Message.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +/** + * @class TAO_Asynch_Queued_Message + * + * @brief Specialize TAO_Queued_Message for asynch requests, + * i.e. oneways sent with SYNC_NONE policy. + * + */ +class TAO_Export TAO_Asynch_Queued_Message : public TAO_Queued_Message +{ +public: + /// Constructor + /** + * @param contents The message block chain that must be sent. + * + * @todo I'm almost sure this class will require a callback + * interface for AMIs sent with SYNC_NONE policy. Those guys + * need to hear when the connection timeouts or closes, but + * cannot block waiting for the message to be delivered. + */ + TAO_Asynch_Queued_Message (const ACE_Message_Block *contents); + + /// Destructor + virtual ~TAO_Asynch_Queued_Message (void); + + /** Implement the Template Methods from TAO_Queued_Message + */ + //@{ + virtual size_t message_length (void) const; + virtual int all_data_sent (void) const; + virtual void fill_iov (int iovcnt_max, int &iovcnt, iovec iov[]) const; + virtual void bytes_transferred (size_t &byte_count); + virtual void destroy (void); + //@} + +private: + /// The number of bytes in the buffer + size_t size_; + + /// The offset in the buffer + /** + * Data up to @c offset has been sent already, only the + * [offset_,size_) range remains to be sent. + */ + size_t offset_; + + /// The buffer containing the complete message. + char *buffer_; +}; + +#include "ace/post.h" +#endif /* TAO_ASYNCH_QUEUED_MESSAGE_H */ diff --git a/TAO/tao/BiDir_Policy_i.cpp b/TAO/tao/BiDir_Policy_i.cpp deleted file mode 100644 index 3a02dbd8a5c..00000000000 --- a/TAO/tao/BiDir_Policy_i.cpp +++ /dev/null @@ -1,79 +0,0 @@ -// $Id$ - -#include "tao/BiDir_Policy_i.h" -#include "tao/Stub.h" - -ACE_RCSID(TAO, BiDir_Policy_i, "$Id$") - - - -#if ! defined (__ACE_INLINE__) -#include "tao/BiDir_Policy_i.inl" -#endif /* __ACE_INLINE__ */ - -TAO_BidirectionalPolicy::TAO_BidirectionalPolicy ( - const BiDirPolicy::BidirectionalPolicyValue val) - : value_ (val) -{ -} - -TAO_BidirectionalPolicy::TAO_BidirectionalPolicy (const TAO_BidirectionalPolicy &rhs) - : BiDirPolicy::BidirectionalPolicy (), - TAO_Local_RefCounted_Object (), - value_ (rhs.value_) -{ -} - - - -CORBA::PolicyType -TAO_BidirectionalPolicy::policy_type (CORBA_Environment &) - ACE_THROW_SPEC ((CORBA::SystemException)) -{ - // Future policy implementors: notice how this minimizes the - // footprint of the class. - return BiDirPolicy::BIDIRECTIONAL_POLICY_TYPE; -} - - -TAO_BidirectionalPolicy * -TAO_BidirectionalPolicy::clone (void) const -{ - TAO_BidirectionalPolicy *copy = 0; - ACE_NEW_RETURN (copy, - TAO_BidirectionalPolicy (*this), - 0); - return copy; -} - -CORBA::Policy_ptr -TAO_BidirectionalPolicy::copy (CORBA_Environment &ACE_TRY_ENV) - ACE_THROW_SPEC ((CORBA::SystemException)) -{ - // Future policy implementors: notice how the following code is - // exception safe! - - TAO_BidirectionalPolicy* tmp; - ACE_NEW_THROW_EX (tmp, TAO_BidirectionalPolicy (*this), - CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_NO)); - ACE_CHECK_RETURN (CORBA::Policy::_nil ()); - - return tmp; -} - -void -TAO_BidirectionalPolicy::destroy (CORBA_Environment &) - ACE_THROW_SPEC ((CORBA::SystemException)) -{ -} - - -BiDirPolicy::BidirectionalPolicyValue -TAO_BidirectionalPolicy::value ( - CORBA::Environment &) - ACE_THROW_SPEC (( - CORBA::SystemException)) -{ - return this->value_; -} diff --git a/TAO/tao/Block_Flushing_Strategy.cpp b/TAO/tao/Block_Flushing_Strategy.cpp new file mode 100644 index 00000000000..96a6b3f12d1 --- /dev/null +++ b/TAO/tao/Block_Flushing_Strategy.cpp @@ -0,0 +1,52 @@ +// -*- C++ -*- +// $Id$ + +#include "Block_Flushing_Strategy.h" +#include "Transport.h" +#include "Queued_Message.h" + +ACE_RCSID(tao, Block_Flushing_Strategy, "$Id$") + +int +TAO_Block_Flushing_Strategy::schedule_output (TAO_Transport *transport) +{ + while (!transport->queue_is_empty_i ()) + { + int result = transport->drain_queue_i (); + if (result == -1) + return -1; + } + return 0; +} + +int +TAO_Block_Flushing_Strategy::cancel_output (TAO_Transport *) +{ + return 0; +} + +int +TAO_Block_Flushing_Strategy::flush_message (TAO_Transport *transport, + TAO_Queued_Message *msg, + ACE_Time_Value *) +{ + while (!msg->all_data_sent ()) + { + int result = transport->handle_output (); + if (result == -1) + return -1; + } + return 0; +} + +int +TAO_Block_Flushing_Strategy::flush_transport (TAO_Transport *transport) +{ + while (!transport->queue_is_empty ()) + { + int result = transport->handle_output (); + if (result == -1) + return -1; + } + return 0; +} diff --git a/TAO/tao/Block_Flushing_Strategy.h b/TAO/tao/Block_Flushing_Strategy.h new file mode 100644 index 00000000000..9b41ef8dd17 --- /dev/null +++ b/TAO/tao/Block_Flushing_Strategy.h @@ -0,0 +1,40 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Block_Flushing_Strategy.h + * + * $Id$ + * + * @author Carlos O'Ryan <coryan@uci.edu> + */ +//============================================================================= + +#ifndef TAO_BLOCK_FLUSHING_STRATEGY_H +#define TAO_BLOCK_FLUSHING_STRATEGY_H +#include "ace/pre.h" + +#include "Flushing_Strategy.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +/** + * @class TAO_Block_Flushing_Strategy + * + * @brief Implement a flushing strategy that blocks on write to flush + */ +class TAO_Export TAO_Block_Flushing_Strategy : public TAO_Flushing_Strategy +{ +public: + virtual int schedule_output (TAO_Transport *transport); + virtual int cancel_output (TAO_Transport *transport); + virtual int flush_message (TAO_Transport *transport, + TAO_Queued_Message *msg, + ACE_Time_Value *max_wait_time); + virtual int flush_transport (TAO_Transport *transport); +}; + +#include "ace/post.h" +#endif /* TAO_BLOCK_FLUSHING_STRATEGY_H */ diff --git a/TAO/tao/Flushing_Strategy.cpp b/TAO/tao/Flushing_Strategy.cpp new file mode 100644 index 00000000000..82a66ec1427 --- /dev/null +++ b/TAO/tao/Flushing_Strategy.cpp @@ -0,0 +1,10 @@ +// -*- C++ -*- +// $Id$ + +#include "Flushing_Strategy.h" + +ACE_RCSID(tao, Flushing_Strategy, "$Id$") + +TAO_Flushing_Strategy::~TAO_Flushing_Strategy (void) +{ +} diff --git a/TAO/tao/Flushing_Strategy.h b/TAO/tao/Flushing_Strategy.h new file mode 100644 index 00000000000..0873936ccf4 --- /dev/null +++ b/TAO/tao/Flushing_Strategy.h @@ -0,0 +1,69 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Flushing_Strategy.h + * + * $Id$ + * + * @author Carlos O'Ryan <coryan@uci.edu> + */ +//============================================================================= + +#ifndef TAO_FLUSHING_STRATEGY_H +#define TAO_FLUSHING_STRATEGY_H +#include "ace/pre.h" + +#include "corbafwd.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class TAO_Transport; +class TAO_Queued_Message; + +/** + * @class TAO_Flushing_Strategy + * + * @brief Define the interface for the flushing strategy, i.e. the + * algorithm that controls how does the ORB flush outgoing + * data. + * + * Please read the documentation in the TAO_Transport class to find + * out more about the design of the outgoing data path. + * + * Some applications can block the current thread whenever they are + * sending out data. In those cases they can obtain better + * performance by blocking in calls to write() than by participating + * in the Leader/Followers protocol to shared the ORB Reactor. + * + * This strategy controls how does the ORB schedule and cancel + * reactive I/O, if there is no reactive I/O the strategy is just a + * no-op. + * + */ +class TAO_Export TAO_Flushing_Strategy +{ +public: + /// Destructor + virtual ~TAO_Flushing_Strategy (void); + + /// Schedule the transport argument to be flushed + virtual int schedule_output (TAO_Transport *transport) = 0; + + /// Cancel all scheduled output for the transport argument + virtual int cancel_output (TAO_Transport *transport) = 0; + + /// Wait until msg is sent out. Potentially other messages are + /// flushed too, for example, because there are ahead in the queue. + virtual int flush_message (TAO_Transport *transport, + TAO_Queued_Message *msg, + ACE_Time_Value *max_wait_time) = 0; + + /// Wait until the transport has no messages queued. + virtual int flush_transport (TAO_Transport *transport) = 0; +}; + +#include "ace/post.h" +#endif /* TAO_FLUSHING_STRATEGY_H */ diff --git a/TAO/tao/GIOP_Message_Base.cpp b/TAO/tao/GIOP_Message_Base.cpp index 7299518bdcb..c8f8a297b02 100644 --- a/TAO/tao/GIOP_Message_Base.cpp +++ b/TAO/tao/GIOP_Message_Base.cpp @@ -15,9 +15,7 @@ # include "GIOP_Message_Base.i" #endif /* __ACE_INLINE__ */ -ACE_RCSID (tao, - GIOP_Message_Base, - "$Id$") +ACE_RCSID (tao, GIOP_Message_Base, "$Id$") TAO_GIOP_Message_Base::TAO_GIOP_Message_Base (TAO_ORB_Core *orb_core, size_t input_cdr_size) @@ -603,8 +601,8 @@ TAO_GIOP_Message_Base::process_request (TAO_Transport *transport, int result = 0; if (response_required) - { - CORBA::UNKNOWN exception (CORBA::SystemException::_tao_minor_code + { + CORBA::UNKNOWN exception (CORBA::SystemException::_tao_minor_code (TAO_UNHANDLED_SERVER_CXX_EXCEPTION, 0), CORBA::COMPLETED_MAYBE); @@ -857,7 +855,8 @@ TAO_GIOP_Message_Base::send_error (TAO_Transport *transport) ACE_Message_Block message_block(&data_block); message_block.wr_ptr (TAO_GIOP_MESSAGE_HEADER_LEN); - int result = transport->send (&message_block); + size_t bt; + int result = transport->send_message_block_chain (&message_block, bt); if (result == -1) { if (TAO_debug_level > 0) @@ -990,7 +989,9 @@ TAO_GIOP_Message_Base:: ACE_Message_Block message_block(&data_block); message_block.wr_ptr (TAO_GIOP_MESSAGE_HEADER_LEN); - if (transport->send (&message_block) == -1 && errno != ENOENT) + size_t bt; + int result = transport->send_message_block_chain (&message_block, bt); + if (result == -1) { if (TAO_debug_level > 0) ACE_ERROR ((LM_ERROR, diff --git a/TAO/tao/GIOP_Message_Handler.cpp b/TAO/tao/GIOP_Message_Handler.cpp index 63cab8f864b..e3de1b47e46 100644 --- a/TAO/tao/GIOP_Message_Handler.cpp +++ b/TAO/tao/GIOP_Message_Handler.cpp @@ -173,7 +173,8 @@ TAO_GIOP_Message_Handler::parse_magic_bytes (void) // For the present... if (TAO_debug_level > 0) ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) bad header, magic word [%c%c%c%c]\n"), + ACE_TEXT ("TAO (%P|%t) bad header, " + "magic word [%2.2x,%2.2x,%2.2x,%2.2x]\n"), buf[0], buf[1], buf[2], @@ -488,8 +489,24 @@ TAO_GIOP_Message_Handler::read_messages (TAO_Transport *transport) // Now we have a succesful read. First adjust the write pointer this->current_buffer_.wr_ptr (n); - if (TAO_debug_level > 8) + if (TAO_debug_level == 2) { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - GIOP_Message_Handler::read_messages" + " received %d bytes\n", + n)); + + size_t len; + for (size_t offset = 0; offset < size_t(n); offset += len) + { + len = n - offset; + if (len > 512) + len = 512; + ACE_HEX_DUMP ((LM_DEBUG, + this->current_buffer_.wr_ptr () + offset, + len, + "TAO (%P|%t) - read_messages ")); + } ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - received %d bytes \n", n)); } diff --git a/TAO/tao/GIOP_Message_Lite.cpp b/TAO/tao/GIOP_Message_Lite.cpp index ecd875cd198..2007977a85f 100644 --- a/TAO/tao/GIOP_Message_Lite.cpp +++ b/TAO/tao/GIOP_Message_Lite.cpp @@ -16,6 +16,8 @@ # include "tao/GIOP_Message_Lite.i" #endif /* __ACE_INLINE__ */ +ACE_RCSID(tao, GIOP_Message_Lite, "$Id$") + static const size_t TAO_GIOP_LITE_HEADER_LEN = 5; static const size_t TAO_GIOP_LITE_MESSAGE_SIZE_OFFSET = 0; static const size_t TAO_GIOP_LITE_MESSAGE_TYPE_OFFSET = 4; @@ -1369,7 +1371,9 @@ TAO_GIOP_Message_Lite::send_error (TAO_Transport *transport) ACE_Message_Block message_block(&data_block); message_block.wr_ptr (TAO_GIOP_LITE_HEADER_LEN); - int result = transport->send (&message_block); + size_t bt; + int result = transport->send_message_block_chain (&message_block, + bt); if (result == -1) { if (TAO_debug_level > 0) diff --git a/TAO/tao/IIOP_Connection_Handler.cpp b/TAO/tao/IIOP_Connection_Handler.cpp index 0ee060fa2e4..3073acd10a2 100644 --- a/TAO/tao/IIOP_Connection_Handler.cpp +++ b/TAO/tao/IIOP_Connection_Handler.cpp @@ -1,6 +1,5 @@ // $Id$ - #include "tao/IIOP_Connection_Handler.h" #include "tao/Timeprobe.h" #include "tao/debug.h" @@ -18,9 +17,7 @@ # include "tao/IIOP_Connection_Handler.i" #endif /* ! __ACE_INLINE__ */ -ACE_RCSID(tao, IIOP_Connect, "$Id$") - - +ACE_RCSID(tao, IIOP_Connection_Handler, "$Id$") TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler (ACE_Thread_Manager *t) : TAO_IIOP_SVC_HANDLER (t, 0 , 0), @@ -58,22 +55,8 @@ TAO_IIOP_Connection_Handler::TAO_IIOP_Connection_Handler (TAO_ORB_Core *orb_core TAO_IIOP_Connection_Handler::~TAO_IIOP_Connection_Handler (void) { - if (this->transport () != 0) { - // If the socket has not already been closed. - if (this->get_handle () != ACE_INVALID_HANDLE) - { - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (); - } - else - { - // Dequeue messages and delete message blocks. - this->transport ()->dequeue_all (); - } - } } - int TAO_IIOP_Connection_Handler::open (void*) { @@ -237,9 +220,6 @@ TAO_IIOP_Connection_Handler::handle_close (ACE_HANDLE handle, // Close the handle.. if (this->get_handle () != ACE_INVALID_HANDLE) { - // Send the buffered messages first - this->transport ()->send_buffered_messages (); - // Mark the entry as invalid this->transport ()->mark_invalid (); @@ -263,28 +243,26 @@ TAO_IIOP_Connection_Handler::fetch_handle (void) return this->get_handle (); } - int TAO_IIOP_Connection_Handler::handle_timeout (const ACE_Time_Value &, const void *) { - // This method is called when buffering timer expires. - // - ACE_Time_Value *max_wait_time = 0; - - TAO_Stub *stub = 0; - int has_timeout; - this->orb_core ()->call_timeout_hook (stub, - has_timeout, - *max_wait_time); - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (max_wait_time); + if (this->transport ()->handle_output () == -1) + { + return -1; + } return 0; } int +TAO_IIOP_Connection_Handler::handle_output (ACE_HANDLE) +{ + return this->transport ()->handle_output (); +} + +int TAO_IIOP_Connection_Handler::add_transport_to_cache (void) { ACE_INET_Addr addr; diff --git a/TAO/tao/IIOP_Connection_Handler.h b/TAO/tao/IIOP_Connection_Handler.h index 97d91734ab7..4a14d8a5d2d 100644 --- a/TAO/tao/IIOP_Connection_Handler.h +++ b/TAO/tao/IIOP_Connection_Handler.h @@ -1,4 +1,5 @@ // This may look like C, but it's really -*- C++ -*- + // =================================================================== /** * @file IIOP_Connection_Handler.h @@ -114,11 +115,15 @@ public: virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0); + /// Documented in ACE_Event_Handler + virtual int handle_output (ACE_HANDLE); + /// Add ourselves to Cache. int add_transport_to_cache (void); /// Process the <listen_list> int process_listen_point_list (IIOP::ListenPointList &listen_list); + protected: /// = Event Handler overloads diff --git a/TAO/tao/IIOP_Endpoint.cpp b/TAO/tao/IIOP_Endpoint.cpp index bbac4ef3f30..5b194b5d20b 100644 --- a/TAO/tao/IIOP_Endpoint.cpp +++ b/TAO/tao/IIOP_Endpoint.cpp @@ -3,12 +3,10 @@ #include "tao/IIOP_Endpoint.h" -#include "tao/IIOP_Connection_Handler.h" #include "tao/debug.h" ACE_RCSID(tao, IIOP_Endpoint, "$Id$") - #if !defined (__ACE_INLINE__) # include "tao/IIOP_Endpoint.i" #endif /* __ACE_INLINE__ */ diff --git a/TAO/tao/IIOP_Transport.cpp b/TAO/tao/IIOP_Transport.cpp index 4799b62a1e5..d927938164d 100644 --- a/TAO/tao/IIOP_Transport.cpp +++ b/TAO/tao/IIOP_Transport.cpp @@ -1,5 +1,4 @@ // This may look like C, but it's really -*- C++ -*- -// // $Id$ #include "tao/IIOP_Transport.h" @@ -23,9 +22,7 @@ # include "tao/IIOP_Transport.i" #endif /* ! __ACE_INLINE__ */ -ACE_RCSID (TAO, - IIOP_Transport, - "$Id$") +ACE_RCSID (tao, IIOP_Transport, "$Id$") TAO_IIOP_Transport::TAO_IIOP_Transport (TAO_IIOP_Connection_Handler *handler, TAO_ORB_Core *orb_core, @@ -54,14 +51,6 @@ TAO_IIOP_Transport::~TAO_IIOP_Transport (void) delete this->messaging_object_; } -#if 0 -ACE_HANDLE -TAO_IIOP_Transport::handle (void) -{ - return this->connection_handler_->get_handle (); -} -#endif - ACE_Event_Handler * TAO_IIOP_Transport::event_handler_i (void) { @@ -75,14 +64,16 @@ TAO_IIOP_Transport::messaging_object (void) } ssize_t -TAO_IIOP_Transport::send_i (const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time, - size_t *bytes_transferred) +TAO_IIOP_Transport::send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *max_wait_time) { - return ACE::send_n (this->connection_handler_->get_handle (), - message_block, - max_wait_time, - bytes_transferred); + ssize_t retval = this->connection_handler_->peer ().sendv (iov, iovcnt, + max_wait_time); + if (retval > 0) + bytes_transferred = retval; + + return retval; } ssize_t @@ -135,6 +126,21 @@ TAO_IIOP_Transport::read_process_message (ACE_Time_Value *max_wait_time, int TAO_IIOP_Transport::register_handler_i (void) { + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - IIOP_Transport::register_handler %d\n", + this->id ())); + } + if (this->connection_handler_->is_registered ()) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - IIOP_Transport::register_handler %d" + ", already registered\n", + this->id ())); + return 0; + } + // @@ It seems like this method should go away, the right reactor is // picked at object creation time. ACE_Reactor *r = this->orb_core_->reactor (); @@ -187,7 +193,7 @@ TAO_IIOP_Transport::send_message (TAO_OutputCDR &stream, return -1; // This guarantees to send all data (bytes) or return an error. - ssize_t n = this->send_or_buffer (stub, + ssize_t n = this->send_message_i (stub, twoway, stream.begin (), max_wait_time); @@ -203,17 +209,6 @@ TAO_IIOP_Transport::send_message (TAO_OutputCDR &stream, return -1; } - // EOF. - if (n == 0) - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") - ACE_TEXT ("EOF, closing transport %d\n"), - this->id ())); - return -1; - } - return 1; } @@ -274,7 +269,6 @@ TAO_IIOP_Transport::tear_listen_point_list (TAO_InputCDR &cdr) return this->connection_handler_->process_listen_point_list (listen_list); } - int TAO_IIOP_Transport::process_message (void) { @@ -521,11 +515,3 @@ TAO_IIOP_Transport::transition_handler_state_i (void) { this->connection_handler_ = 0; } - -#if 0 -TAO_Connection_Handler* -TAO_IIOP_Transport::connection_handler (void) const -{ - return this->connection_handler_; -} -#endif diff --git a/TAO/tao/IIOP_Transport.h b/TAO/tao/IIOP_Transport.h index 6190c9b353e..940ab085b2e 100644 --- a/TAO/tao/IIOP_Transport.h +++ b/TAO/tao/IIOP_Transport.h @@ -64,33 +64,24 @@ public: protected: /** @name Overridden Template Methods * - * These are implementations of template methods declared by TAO_Transport. + * Please check the documentation in "tao/Transport.h" for more + * details. */ //@{ - /// Access connection_handler_ as an <code>ACE_Event_Handler</code>. - /// Must be called with transport's lock held. virtual ACE_Event_Handler *event_handler_i (void); /// Access the underlying messaging object virtual TAO_Pluggable_Messaging *messaging_object (void); - /// Write the complete Message_Block chain to the connection. - /// Must be called with transport's lock held. - virtual ssize_t send_i (const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0, - size_t *bytes_transferred = 0); + virtual ssize_t send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *timeout = 0); - - /// Read len bytes from into buf. - /// Must be called with transport's lock held. virtual ssize_t recv_i (char *buf, size_t len, const ACE_Time_Value *s = 0); - /// Read and process the message from the connection. The processing - /// of the message is done by delegating the work to the underlying - /// messaging object virtual int read_process_message (ACE_Time_Value *max_time_value = 0, int block =0); @@ -118,11 +109,9 @@ public: TAO_Target_Specification &spec, TAO_OutputCDR &msg); - /// Initialising the messaging object virtual int messaging_init (CORBA::Octet major, CORBA::Octet minor); - /// Open the service context list and process it. virtual int tear_listen_point_list (TAO_InputCDR &cdr); //@} diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp index 6be0f121bc8..57681cae07a 100644 --- a/TAO/tao/Invocation.cpp +++ b/TAO/tao/Invocation.cpp @@ -31,9 +31,7 @@ # include "Invocation.i" #endif /* ! __ACE_INLINE__ */ -ACE_RCSID (TAO, - Invocation, - "$Id$") +ACE_RCSID(tao, Invocation, "$Id$") #if defined (ACE_ENABLE_TIMEPROBES) @@ -390,7 +388,7 @@ TAO_GIOP_Invocation::prepare_header (CORBA::Octet response_flags, // Send request. int -TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip, +TAO_GIOP_Invocation::invoke (CORBA::Boolean is_synchronous, CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { @@ -402,18 +400,11 @@ TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip, TAO_INVOKE_EXCEPTION); } - // @@ Alex: the <is_roundtrip> flag will be tricky when we move to - // AMI: now it is used both to indicate the the CORBA request in - // a twoway and that the send_request() operation should block. - // Even for oneways: with AMI it is possible to wait for a - // response (empty) for oneways, just to make sure that they - // arrive, there are policies to control that. - int result = this->transport_->send_request (this->stub_, this->orb_core_, this->out_stream_, - is_roundtrip, + is_synchronous, this->max_wait_time_); // @@ -623,8 +614,7 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request, } // Just send the request, without trying to wait for the reply. - int retval = TAO_GIOP_Invocation::invoke (1, - ACE_TRY_ENV); + int retval = TAO_GIOP_Invocation::invoke (1, ACE_TRY_ENV); ACE_CHECK_RETURN (retval); if (retval != TAO_INVOKE_OK) @@ -662,7 +652,8 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request, CORBA::ULong msecs = this->max_wait_time_->msec (); ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) Timeout on recv is <%u>\n"), + "TAO (%P|%t) - Synch_Invocation::invoke_i, " + "timeout on recv is <%u>\n", msecs)); } @@ -676,7 +667,8 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request, CORBA::ULong msecs = this->max_wait_time_->msec (); ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) Timeout after recv is <%u> status <%d>\n"), + "TAO (%P|%t) Synch_Invocation::invoke_i, " + "timeout after recv is <%u> status <%d>\n", msecs, reply_error)); } @@ -853,8 +845,7 @@ TAO_GIOP_Twoway_Invocation::invoke (TAO_Exception_Data *excepts, { TAO_FUNCTION_PP_TIMEPROBE (TAO_GIOP_INVOCATION_INVOKE_START); - int retval = this->invoke_i (0, - ACE_TRY_ENV); + int retval = this->invoke_i (0, ACE_TRY_ENV); ACE_CHECK_RETURN (retval); // A TAO_INVOKE_EXCEPTION status, but no exception raised means that @@ -946,7 +937,7 @@ TAO_GIOP_Oneway_Invocation::TAO_GIOP_Oneway_Invocation ( sync_scope_ (TAO::SYNC_WITH_TRANSPORT) { int has_synchronization = 0; - int scope = 0; + int scope = this->sync_scope_; this->orb_core_->call_sync_scope_hook (this->stub_, has_synchronization, scope); @@ -967,18 +958,19 @@ int TAO_GIOP_Oneway_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - if (this->sync_scope_ == TAO::SYNC_WITH_TRANSPORT - || this->sync_scope_ == TAO::SYNC_NONE + if (this->sync_scope_ == TAO::SYNC_NONE || this->sync_scope_ == TAO::SYNC_EAGER_BUFFERING || this->sync_scope_ == TAO::SYNC_DELAYED_BUFFERING) { - return TAO_GIOP_Invocation::invoke (0, - ACE_TRY_ENV); + return TAO_GIOP_Invocation::invoke (0, ACE_TRY_ENV); + } + if (this->sync_scope_ == TAO::SYNC_WITH_TRANSPORT) + { + return TAO_GIOP_Invocation::invoke (1, ACE_TRY_ENV); } - int retval = this->invoke_i (0, - ACE_TRY_ENV); - ACE_CHECK_RETURN (retval); + int retval = this->invoke_i (0, ACE_TRY_ENV); + ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); // A TAO_INVOKE_EXCEPTION status, but no exception raised means that // we have a user exception. @@ -1033,8 +1025,7 @@ TAO_GIOP_Locate_Request_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) TAO_INVOKE_EXCEPTION); } - CORBA::ULong locate_status = this->invoke_i (1, - ACE_TRY_ENV); + CORBA::ULong locate_status = this->invoke_i (1, ACE_TRY_ENV); ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); switch (locate_status) diff --git a/TAO/tao/Invocation.h b/TAO/tao/Invocation.h index c6b6cc9f334..66d08ee9cbd 100644 --- a/TAO/tao/Invocation.h +++ b/TAO/tao/Invocation.h @@ -178,12 +178,16 @@ protected: /** * Returns TAO_INVOKE_RESTART if the write call failed and the * request must be re-attempted. - * @par + * + * @param is_synchronous If set invoke() does not return until the + * message is completely delivered to the underlying + * transport mechanism, or an error is detected. + * * Notice that the same profile is tried again because it may be * that the server closed the connection simply to release * resources. */ - int invoke (CORBA::Boolean is_roundtrip, + int invoke (CORBA::Boolean is_synchronous, CORBA_Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)); diff --git a/TAO/tao/Makefile b/TAO/tao/Makefile index f665706a896..d5d0401c4dd 100644 --- a/TAO/tao/Makefile +++ b/TAO/tao/Makefile @@ -238,7 +238,14 @@ ORB_CORE_FILES = \ CodecFactory_ORBInitializer \ CDR_Encaps_Codec \ Endpoint_Selector_Factory \ - RT_Endpoint_Selector_Factory + RT_Endpoint_Selector_Factory \ + Flushing_Strategy \ + Block_Flushing_Strategy \ + Reactive_Flushing_Strategy \ + Queued_Message \ + Synch_Queued_Message \ + Asynch_Queued_Message \ + Transport_Timer DYNAMIC_ANY_FILES = diff --git a/TAO/tao/Makefile.bor b/TAO/tao/Makefile.bor index d01942fd890..a00a2f9d06c 100644 --- a/TAO/tao/Makefile.bor +++ b/TAO/tao/Makefile.bor @@ -132,6 +132,7 @@ OBJFILES = \ $(OBJDIR)\Parser_Registry.obj \ $(OBJDIR)\Pluggable.obj \ $(OBJDIR)\Transport.obj \ + $(OBJDIR)\Transport_Timer.obj \ $(OBJDIR)\Pluggable_Messaging.obj \ $(OBJDIR)\Pluggable_Messaging_Utils.obj \ $(OBJDIR)\Policy_Manager.obj \ diff --git a/TAO/tao/Messaging_Policy_i.cpp b/TAO/tao/Messaging_Policy_i.cpp index a7540f9c1db..0aeea2ea279 100644 --- a/TAO/tao/Messaging_Policy_i.cpp +++ b/TAO/tao/Messaging_Policy_i.cpp @@ -156,10 +156,9 @@ TAO_RelativeRoundtripTimeoutPolicy::set_time_value (ACE_Time_Value &time_value) if (TAO_debug_level > 0) { - CORBA::ULong msecs = - ACE_static_cast(CORBA::ULong, microseconds / 1000); + CORBA::ULong msecs = time_value.msec (); ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) Timeout is <%u>\n"), + ACE_TEXT ("TAO (%P|%t) - Timeout is <%u>\n"), msecs)); } } @@ -290,4 +289,3 @@ TAO_Sync_Scope_Policy::destroy (CORBA_Environment &) } #endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ - diff --git a/TAO/tao/ORB_Core.cpp b/TAO/tao/ORB_Core.cpp index 15a8f761e39..1390ffe0767 100644 --- a/TAO/tao/ORB_Core.cpp +++ b/TAO/tao/ORB_Core.cpp @@ -38,6 +38,7 @@ #include "IORInfo.h" +#include "Flushing_Strategy.h" #if defined(ACE_MVS) #include "ace/Codeset_IBM1047.h" @@ -47,10 +48,7 @@ # include "ORB_Core.i" #endif /* ! __ACE_INLINE__ */ -ACE_RCSID (TAO, - ORB_Core, - "$Id$") - +ACE_RCSID(tao, ORB_Core, "$Id$") // **************************************************************** @@ -162,6 +160,7 @@ TAO_ORB_Core::TAO_ORB_Core (const char *orbid) transport_cache_ (), bidir_adapter_ (0), bidir_giop_policy_ (0) + , flushing_strategy_ (0) { #if defined(ACE_MVS) ACE_NEW (this->from_iso8859_, ACE_IBM1047_ISO8859); @@ -206,6 +205,8 @@ TAO_ORB_Core::TAO_ORB_Core (const char *orbid) TAO_ORB_Core::~TAO_ORB_Core (void) { + delete this->flushing_strategy_; + ACE_OS::free (this->orbid_); delete this->from_iso8859_; @@ -1014,6 +1015,9 @@ TAO_ORB_Core::init (int &argc, char *argv[], CORBA::Environment &ACE_TRY_ENV) // init the ORB core's pointer this->protocol_factories_ = trf->get_protocol_factories (); + // Initialize the flushing strategy + this->flushing_strategy_ = trf->create_flushing_strategy (); + // Now that we have a complete list of available protocols and their // related factory objects, set default policies and initialize the // registries! @@ -1971,9 +1975,15 @@ TAO_ORB_Core::run (ACE_Time_Value *tv, if (TAO_debug_level >= 3) ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) - blocking on handle events\n"))); + ACE_TEXT ("TAO (%P|%t) - calling handle_events\n"))); + result = r->handle_events (tv); + if (TAO_debug_level >= 3) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO (%P|%t) - handle_events returns %d\n"), + result)); + if (result == -1) { // An error, terminate the loop diff --git a/TAO/tao/ORB_Core.h b/TAO/tao/ORB_Core.h index 3a6b2f32d11..07ffd89ea90 100644 --- a/TAO/tao/ORB_Core.h +++ b/TAO/tao/ORB_Core.h @@ -75,6 +75,8 @@ class TAO_ServerRequest; class TAO_Protocols_Hooks; class TAO_BiDir_Adapter; +class TAO_Flushing_Strategy; + #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) class TAO_Eager_Buffering_Sync_Strategy; @@ -831,12 +833,21 @@ public: CORBA::Boolean bidir_giop_policy (void); void bidir_giop_policy (CORBA::Boolean); - /// Return the table that maps object key/name to de-stringified /// object reference. It is needed for supporting local objects in /// the resolve_initial_references() mechanism. TAO_Object_Ref_Table &object_ref_table (void); + /// Return the flushing strategy + /** + * The flushing strategy is created by the resource factory, and it + * is used by the ORB to control the mechanism used to flush the + * outgoing data queues. + * The flushing strategies are stateless, therefore, there is only + * one per ORB. + */ + TAO_Flushing_Strategy *flushing_strategy (void); + protected: /// Destructor is protected since the ORB Core is a reference @@ -1180,6 +1191,9 @@ protected: /// Bir Dir GIOP policy value CORBA::Boolean bidir_giop_policy_; + + /// Hold the flushing strategy + TAO_Flushing_Strategy *flushing_strategy_; }; // **************************************************************** diff --git a/TAO/tao/ORB_Core.i b/TAO/tao/ORB_Core.i index c7cfd3e8de4..d5cfc48f460 100644 --- a/TAO/tao/ORB_Core.i +++ b/TAO/tao/ORB_Core.i @@ -49,6 +49,11 @@ TAO_ORB_Core::object_ref_table (void) return this->object_ref_table_; } +ACE_INLINE TAO_Flushing_Strategy * +TAO_ORB_Core::flushing_strategy (void) +{ + return this->flushing_strategy_; +} ACE_INLINE CORBA::Boolean TAO_ORB_Core::service_profile_selection (TAO_MProfile &mprofile, diff --git a/TAO/tao/PortableServer/Object_Adapter.cpp b/TAO/tao/PortableServer/Object_Adapter.cpp index 76ce6d0dd3e..fe50b820c99 100644 --- a/TAO/tao/PortableServer/Object_Adapter.cpp +++ b/TAO/tao/PortableServer/Object_Adapter.cpp @@ -1677,7 +1677,6 @@ TAO_POA_Current::implementation (TAO_POA_Current_Impl *new_current) // Common typedefs. typedef TAO_Object_Adapter::poa_name key; typedef TAO_POA *value; -typedef ACE_Reverse_Lock<ACE_Lock> REVERSE_LOCK; typedef ACE_Pair<key, value> expanded_value; typedef ACE_Reference_Pair<const key, value> tao_value_type; @@ -1685,9 +1684,6 @@ typedef ACE_Equal_To<key> compare_keys; typedef TAO_ObjectId_Hash hash_key; typedef ACE_Noop_Key_Generator<key> noop_key_generator; -template class ACE_Reverse_Lock<ACE_Lock>; -template class ACE_Guard<REVERSE_LOCK>; - template class auto_ptr<TAO_Object_Adapter::Hint_Strategy>; template class auto_ptr<TAO_Object_Adapter::transient_poa_map>; @@ -1759,7 +1755,6 @@ template class ACE_Unbounded_Set_Iterator<TAO_POA_Manager *>; // Common typedefs. typedef TAO_Object_Adapter::poa_name key; typedef TAO_POA *value; -typedef ACE_Reverse_Lock<ACE_Lock> REVERSE_LOCK; typedef ACE_Pair<key, value> expanded_value; typedef ACE_Reference_Pair<const key, value> tao_value_type; @@ -1767,9 +1762,6 @@ typedef ACE_Equal_To<key> compare_keys; typedef TAO_ObjectId_Hash hash_key; typedef ACE_Noop_Key_Generator<key> noop_key_generator; -#pragma instantiate ACE_Reverse_Lock<ACE_Lock> -#pragma instantiate ACE_Guard<REVERSE_LOCK> - #pragma instantiate auto_ptr<TAO_Object_Adapter::Hint_Strategy> #pragma instantiate auto_ptr<TAO_Object_Adapter::transient_poa_map> diff --git a/TAO/tao/Queued_Message.cpp b/TAO/tao/Queued_Message.cpp new file mode 100644 index 00000000000..1cd30ae2e2e --- /dev/null +++ b/TAO/tao/Queued_Message.cpp @@ -0,0 +1,97 @@ +// -*- C++ -*- +// $Id$ + +#include "Queued_Message.h" + +#if !defined (__ACE_INLINE__) +# include "Queued_Message.inl" +#endif /* __ACE_INLINE__ */ + +ACE_RCSID(tao, Queued_Message, "$Id$") + +TAO_Queued_Message::TAO_Queued_Message (void) + : connection_closed_ (0) + , send_failure_ (0) + , timeout_ (0) + , next_ (0) + , prev_ (0) +{ +} + +TAO_Queued_Message::~TAO_Queued_Message (void) +{ +} + +void +TAO_Queued_Message::connection_closed (void) +{ + this->connection_closed_ = 1; +} + +void +TAO_Queued_Message::send_failure (void) +{ + this->send_failure_ = 1; +} + +void +TAO_Queued_Message::timeout (void) +{ + this->timeout_ = 1; +} + +void +TAO_Queued_Message::remove_from_list (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail) +{ + if (this->prev_ != 0) + this->prev_->next_ = this->next_; + else + head = this->next_; + + if (this->next_ != 0) + this->next_->prev_ = this->prev_; + else + tail = this->prev_; + + this->next_ = 0; + this->prev_ = 0; +} + +void +TAO_Queued_Message::push_back (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail) +{ + if (tail == 0) + { + tail = this; + head = this; + this->next_ = 0; + this->prev_ = 0; + return; + } + + tail->next_ = this; + this->prev_ = tail; + this->next_ = 0; + tail = this; +} + +void +TAO_Queued_Message::push_front (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail) +{ + if (head == 0) + { + tail = this; + head = this; + this->next_ = 0; + this->prev_ = 0; + return; + } + + head->prev_ = this; + this->next_ = head; + this->prev_ = 0; + head = this; +} diff --git a/TAO/tao/Queued_Message.h b/TAO/tao/Queued_Message.h new file mode 100644 index 00000000000..11eb9861bfc --- /dev/null +++ b/TAO/tao/Queued_Message.h @@ -0,0 +1,203 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Queued_Message.h + * + * $Id$ + * + * @author Carlos O'Ryan <coryan@uci.edu> + */ +//============================================================================= + +#ifndef TAO_QUEUED_MESSAGE_H +#define TAO_QUEUED_MESSAGE_H +#include "ace/pre.h" + +#include "corbafwd.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class ACE_Message_Block; + +/** + * @class TAO_Queued_Message + * + * @brief Represent messages queued in the outgoing data path of the + * TAO_Transport class. + * + * Please read the documentation in the TAO_Transport class to find + * out more about the design of the outgoing data path. + * + * In some configurations TAO needs to maintain a per-connection queue + * of outgoing messages. This queue is drained by the pluggable + * protocols framework, normally under control of the ACE_Reactor, but + * other configurations are conceivable. The elements in the queue + * may may removed early, for example, because the application can + * specify timeouts for each message, or because the underlying + * connection is broken. + * + * In many cases the message corresponds to some application request, + * the application may be blocked waiting for the request to be sent, + * even more importantlyl, the ORB can be configured to use the + * Leader/Followers strategy, in which case one of the waiting threads + * can be required to wake up before its message completes + * each message may contain a 'Sent_Notifier' + * + * <H4>NOTE:</H4> The contents of the ACE_Message_Block may have been + * allocated from TSS storage, in that case we cannot steal them. + * However, we do not need to perform a deep copy all the time, for + * example, in a twoway request the sending thread blocks until the + * data goes out. The queued message can borrow the memory as it will + * be deallocated by the sending thread when it finishes. + * Oneways and asynchronous calls are another story. + * + * @todo: Change the ORB to allocate oneway and AMI buffer from global + * memory, to avoid the data copy in this path. What happens + * if the there is no queueing? Can we check that before + * allocating the memory? + * + */ +class TAO_Export TAO_Queued_Message +{ +public: + /// Constructor + TAO_Queued_Message (void); + + /// Destructor + virtual ~TAO_Queued_Message (void); + + /// The underlying connection has been closed, release resources and + /// signal waiting threads. + void connection_closed (void); + + /// There was an error while sending the data. + void send_failure (void); + + /// There was a timeout while sending the data + void timeout (void); + + /** @name Intrusive list manipulation + * + * The messages are put in a doubled linked list (for easy insertion + * and removal). To minimize memory allocations the list is + * intrusive, i.e. each element in the list contains the pointers + * for the next and previous element. + * + * The following methods are used to manipulate this implicit list. + * + * @todo: We should implement this as a base template, something + * like:<BR> + * template<class T> Intrusive_Node {<BR> + * public:<BR><BR> + * void next (T *);<BR> + * T* next () const;<BR><BR> + * private:<BR> + * T* next_;<BR> + * };<BR> + * and use it as follows:<BR> + * class TAO_Queued_Message : public Intrusive_Node<TAO_Queued_Message><BR> + * {<BR> + * };<BR> + * + */ + //@{ + /// Set/get the next element in the list + virtual TAO_Queued_Message *next (void) const; + + /// Set/get the previous element in the list + virtual TAO_Queued_Message *prev (void) const; + + /// Remove this element from the list + virtual void remove_from_list (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail); + + /// Insert the current element at the tail of the queue. + virtual void push_back (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail); + + /// Insert the current element at the head of the queue. + virtual void push_front (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail); + //@} + + /** @name Template Methods + */ + //@{ + + /// Return the length of the message + /** + * If the message has been partially sent it returns the number of + * bytes that are still not sent. + */ + virtual size_t message_length (void) const = 0; + + /// Return 1 if all the data has been sent + virtual int all_data_sent (void) const = 0; + + /// Fill up an io vector using the connects of the message + /** + * Different versions of this class represent the message using + * either a single buffer, or a message block. + * This method allows a derived class to fill up the contents of an + * io vector, the TAO_Transport class uses this method to group as + * many messages as possible in an iovector before sending them to + * the OS I/O subsystem. + * + * @param iovcnt_max The number of elements in iov + * @param iovcnt The number of elements already used by iov, this + * method should update this counter + * @param iov The io vector + */ + virtual void fill_iov (int iovcnt_max, int &iovcnt, iovec iov[]) const = 0; + + /// Update the internal state, data has been sent. + /** + * After the TAO_Transport class completes a successful (or + * partially successful) I/O operation it must update the state of + * all the messages queued. This callback method is used by each + * message to update its state and determine if all the data has + * been sent already. + * + * @param byte_count The number of bytes succesfully sent. The + * TAO_Queued_Message should decrement this value + * by the number of bytes that must still be sent. + * @return Returns 1 if the TAO_Queued_Message has any more data to + * send. + */ + virtual void bytes_transferred (size_t &byte_count) = 0; + + /// Reclaim resources + /** + * Reliable messages are allocated from the stack, thus they do not + * be deallocated. + * Asynchronous (SYNC_NONE) messages are allocated from the heap (or + * a pool), they need to be reclaimed explicitly. + */ + virtual void destroy (void) = 0; + //@} + +protected: + /// Set to 1 if the connection was closed + int connection_closed_; + + /// Set to 1 if there was a failure while sending the data + int send_failure_; + + /// Set to 1 if there was a timeout while sending the data + int timeout_; + +private: + /// Implement an intrusive double-linked list for the message queue + TAO_Queued_Message *next_; + TAO_Queued_Message *prev_; +}; + +#if defined (__ACE_INLINE__) +# include "Queued_Message.inl" +#endif /* __ACE_INLINE__ */ + +#include "ace/post.h" +#endif /* TAO_QUEUED_MESSAGE_H */ diff --git a/TAO/tao/Queued_Message.inl b/TAO/tao/Queued_Message.inl new file mode 100644 index 00000000000..e9cd0a9ff4b --- /dev/null +++ b/TAO/tao/Queued_Message.inl @@ -0,0 +1,13 @@ +// $Id$ + +ACE_INLINE TAO_Queued_Message * +TAO_Queued_Message::next (void) const +{ + return this->next_; +} + +ACE_INLINE TAO_Queued_Message * +TAO_Queued_Message::prev (void) const +{ + return this->prev_; +} diff --git a/TAO/tao/Reactive_Flushing_Strategy.cpp b/TAO/tao/Reactive_Flushing_Strategy.cpp new file mode 100644 index 00000000000..0bbc18bf46b --- /dev/null +++ b/TAO/tao/Reactive_Flushing_Strategy.cpp @@ -0,0 +1,77 @@ +// -*- C++ -*- +// $Id$ + +#include "Reactive_Flushing_Strategy.h" +#include "Transport.h" +#include "ORB_Core.h" +#include "Queued_Message.h" +#include "debug.h" + +ACE_RCSID(tao, Reactive_Flushing_Strategy, "$Id$") + +int +TAO_Reactive_Flushing_Strategy::schedule_output (TAO_Transport *transport) +{ + return transport->schedule_output_i (); +} + +int +TAO_Reactive_Flushing_Strategy::cancel_output (TAO_Transport *transport) +{ + return transport->cancel_output_i (); +} + +int +TAO_Reactive_Flushing_Strategy::flush_message (TAO_Transport *transport, + TAO_Queued_Message *msg, + ACE_Time_Value *max_wait_time) +{ + int result = 0; + + // @@ Should we pass this down? Can we? + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + TAO_ORB_Core *orb_core = transport->orb_core (); + + while (!msg->all_data_sent () && result >= 0) + { + result = orb_core->run (max_wait_time, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + return -1; + } + ACE_ENDTRY; + + return result; +} + +int +TAO_Reactive_Flushing_Strategy::flush_transport (TAO_Transport *transport) +{ + // @@ Should we pass this down? Can we? + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + TAO_ORB_Core *orb_core = transport->orb_core (); + + while (!transport->queue_is_empty ()) + { + int result = orb_core->run (0, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (result == -1) + return -1; + } + } + ACE_CATCHANY + { + return -1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tao/Reactive_Flushing_Strategy.h b/TAO/tao/Reactive_Flushing_Strategy.h new file mode 100644 index 00000000000..e1aba16bbb0 --- /dev/null +++ b/TAO/tao/Reactive_Flushing_Strategy.h @@ -0,0 +1,40 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Reactive_Flushing_Strategy.h + * + * $Id$ + * + * @author Carlos O'Ryan <coryan@uci.edu> + */ +//============================================================================= + +#ifndef TAO_REACTIVE_FLUSHING_STRATEGY_H +#define TAO_REACTIVE_FLUSHING_STRATEGY_H +#include "ace/pre.h" + +#include "Flushing_Strategy.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +/** + * @class TAO_Reactive_Flushing_Strategy + * + * @brief Implement a flushing strategy that uses the reactor. + */ +class TAO_Export TAO_Reactive_Flushing_Strategy : public TAO_Flushing_Strategy +{ +public: + virtual int schedule_output (TAO_Transport *transport); + virtual int cancel_output (TAO_Transport *transport); + virtual int flush_message (TAO_Transport *transport, + TAO_Queued_Message *msg, + ACE_Time_Value *max_wait_time); + virtual int flush_transport (TAO_Transport *transport); +}; + +#include "ace/post.h" +#endif /* TAO_REACTIVE_FLUSHING_STRATEGY_H */ diff --git a/TAO/tao/Resource_Factory.h b/TAO/tao/Resource_Factory.h index eeca5e3bb56..7751590bf06 100644 --- a/TAO/tao/Resource_Factory.h +++ b/TAO/tao/Resource_Factory.h @@ -32,6 +32,8 @@ class TAO_Connector_Registry; class TAO_Reactor_Registry; class TAO_Priority_Mapping; +class TAO_Flushing_Strategy; + // **************************************************************** class TAO_Export TAO_Protocol_Item @@ -184,6 +186,10 @@ public: /// Creates the lock for the lock needed in the Cache Map virtual ACE_Lock *create_cached_connection_lock (void); + /// Creates the flushing strategy. The new instance is owned by the + /// caller. + virtual TAO_Flushing_Strategy *create_flushing_strategy (void) = 0; + protected: /** * Loads the default protocols. This method is used so that the diff --git a/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp b/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp index d2b99bec1dc..50dc660bf8e 100644 --- a/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp +++ b/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp @@ -22,8 +22,6 @@ ACE_RCSID(Strategies, SHMIOP_Connect, "$Id$") - - TAO_SHMIOP_Connection_Handler::TAO_SHMIOP_Connection_Handler (ACE_Thread_Manager *t) : TAO_SHMIOP_SVC_HANDLER (t, 0 , 0), TAO_Connection_Handler (0), @@ -57,23 +55,8 @@ TAO_SHMIOP_Connection_Handler::TAO_SHMIOP_Connection_Handler (TAO_ORB_Core *orb_ TAO_SHMIOP_Connection_Handler::~TAO_SHMIOP_Connection_Handler (void) { - if (this->transport () != 0) - { - // If the socket has not already been closed. - if (this->get_handle () != ACE_INVALID_HANDLE) - { - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (); - } - else - { - // Dequeue messages and delete message blocks. - this->transport ()->dequeue_all (); - } - } } - int TAO_SHMIOP_Connection_Handler::open (void*) { @@ -214,9 +197,6 @@ TAO_SHMIOP_Connection_Handler::handle_close (ACE_HANDLE handle, // Close the handle.. if (this->get_handle () != ACE_INVALID_HANDLE) { - // Send the buffered messages first - this->transport ()->send_buffered_messages (); - // Mark the entry as invalid this->transport ()->mark_invalid (); @@ -240,28 +220,17 @@ TAO_SHMIOP_Connection_Handler::fetch_handle (void) return this->get_handle (); } - int TAO_SHMIOP_Connection_Handler::handle_timeout (const ACE_Time_Value &, const void *) { - // This method is called when buffering timer expires. - // - ACE_Time_Value *max_wait_time = 0; - - TAO_Stub *stub = 0; - int has_timeout; - this->orb_core ()->call_timeout_hook (stub, - has_timeout, - *max_wait_time); - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (max_wait_time); + if (this->transport ()->handle_output () == -1) + return -1; return 0; } - int TAO_SHMIOP_Connection_Handler::add_transport_to_cache (void) { diff --git a/TAO/tao/Strategies/SHMIOP_Transport.cpp b/TAO/tao/Strategies/SHMIOP_Transport.cpp index e6e53353061..ae99103d5f6 100644 --- a/TAO/tao/Strategies/SHMIOP_Transport.cpp +++ b/TAO/tao/Strategies/SHMIOP_Transport.cpp @@ -1,14 +1,10 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ - #include "SHMIOP_Transport.h" #if defined (TAO_HAS_SHMIOP) && (TAO_HAS_SHMIOP != 0) -ACE_RCSID (Strategies, SHMIOP_Transport, "$Id$") - - #include "SHMIOP_Connection_Handler.h" #include "SHMIOP_Profile.h" #include "tao/Timeprobe.h" @@ -27,6 +23,7 @@ ACE_RCSID (Strategies, SHMIOP_Transport, "$Id$") # include "SHMIOP_Transport.i" #endif /* ! __ACE_INLINE__ */ +ACE_RCSID (Strategies, SHMIOP_Transport, "$Id$") TAO_SHMIOP_Transport::TAO_SHMIOP_Transport (TAO_SHMIOP_Connection_Handler *handler, TAO_ORB_Core *orb_core, @@ -70,12 +67,23 @@ TAO_SHMIOP_Transport::messaging_object (void) ssize_t -TAO_SHMIOP_Transport::send_i (const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time, - size_t *) +TAO_SHMIOP_Transport::send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *max_wait_time) { - return this->connection_handler_->peer ().send (message_block, - max_wait_time); + bytes_transferred = 0; + for (int i = 0; i < iovcnt; ++i) + { + ssize_t retval = + this->connection_handler_->peer ().send (iov[i].iov_base, + iov[i].iov_len, + max_wait_time); + if (retval > 0) + bytes_transferred += retval; + if (retval <= 0) + return retval; + } + return bytes_transferred; } ssize_t @@ -127,6 +135,21 @@ TAO_SHMIOP_Transport::read_process_message (ACE_Time_Value *max_wait_time, int TAO_SHMIOP_Transport::register_handler_i (void) { + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - IIOP_Transport::register_handler %d\n", + this->id ())); + } + if (this->connection_handler_->is_registered ()) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - IIOP_Transport::register_handler %d" + ", already registered\n", + this->id ())); + return 0; + } + // @@ It seems like this method should go away, the right reactor is // picked at object creation time. ACE_Reactor *r = this->orb_core_->reactor (); @@ -180,7 +203,7 @@ TAO_SHMIOP_Transport::send_message (TAO_OutputCDR &stream, // versions seem to need it though. Leaving it costs little. // This guarantees to send all data (bytes) or return an error. - ssize_t n = this->send_or_buffer (stub, + ssize_t n = this->send_message_i (stub, twoway, stream.begin (), max_wait_time); @@ -196,17 +219,6 @@ TAO_SHMIOP_Transport::send_message (TAO_OutputCDR &stream, return -1; } - // EOF. - if (n == 0) - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") - ACE_TEXT ("EOF, closing transport %d\n"), - this->id ())); - return -1; - } - return 1; } diff --git a/TAO/tao/Strategies/SHMIOP_Transport.h b/TAO/tao/Strategies/SHMIOP_Transport.h index dc679330824..ead847e0e5a 100644 --- a/TAO/tao/Strategies/SHMIOP_Transport.h +++ b/TAO/tao/Strategies/SHMIOP_Transport.h @@ -1,5 +1,6 @@ // This may look like C, but it's really -*- C++ -*- // $Id$ + // =================================================================== /** * @file SHMIOP_Transport.h @@ -10,6 +11,7 @@ * @author Modified by Balachandran Natarajan <bala@cs.wustl.edu> */ // =================================================================== + #ifndef TAO_SHMIOP_TRANSPORT_H #define TAO_SHMIOP_TRANSPORT_H #include "ace/pre.h" @@ -67,9 +69,9 @@ protected: virtual TAO_Pluggable_Messaging *messaging_object (void); /// Write the complete Message_Block chain to the connection. - virtual ssize_t send_i (const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0, - size_t *bytes_transferred = 0); + virtual ssize_t send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *timeout = 0); /// Read len bytes from into buf. virtual ssize_t recv_i (char *buf, diff --git a/TAO/tao/Strategies/UIOP_Connection_Handler.cpp b/TAO/tao/Strategies/UIOP_Connection_Handler.cpp index 113f4925512..9b16ca2a6dc 100644 --- a/TAO/tao/Strategies/UIOP_Connection_Handler.cpp +++ b/TAO/tao/Strategies/UIOP_Connection_Handler.cpp @@ -4,6 +4,8 @@ #if TAO_HAS_UIOP == 1 +#include "UIOP_Transport.h" +#include "UIOP_Endpoint.h" #include "tao/debug.h" #include "tao/ORB_Core.h" #include "tao/ORB.h" @@ -11,18 +13,14 @@ #include "tao/Timeprobe.h" #include "tao/Server_Strategy_Factory.h" #include "tao/Messaging_Policy_i.h" -#include "UIOP_Endpoint.h" #include "tao/Base_Transport_Property.h" +#include "tao/GIOP_Message_Lite.h" #if !defined (__ACE_INLINE__) # include "UIOP_Connection_Handler.inl" #endif /* ! __ACE_INLINE__ */ -ACE_RCSID(Strategies, UIOP_Connect, "$Id$") - -#include "tao/GIOP_Message_Lite.h" - - +ACE_RCSID(Strategies, UIOP_Connection_Handler, "$Id$") TAO_UIOP_Connection_Handler::TAO_UIOP_Connection_Handler (ACE_Thread_Manager *t) : TAO_UIOP_SVC_HANDLER (t, 0 , 0), @@ -60,23 +58,8 @@ TAO_UIOP_Connection_Handler::TAO_UIOP_Connection_Handler (TAO_ORB_Core *orb_core TAO_UIOP_Connection_Handler::~TAO_UIOP_Connection_Handler (void) { - if (this->transport () != 0) { - // If the socket has not already been closed. - if (this->get_handle () != ACE_INVALID_HANDLE) - { - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (); - } - else - { - // Dequeue messages and delete message blocks. - this->transport ()->dequeue_all (); - } - } } - - int TAO_UIOP_Connection_Handler::open (void*) { @@ -196,9 +179,6 @@ TAO_UIOP_Connection_Handler::handle_close (ACE_HANDLE handle, // Close the handle.. if (this->get_handle () != ACE_INVALID_HANDLE) { - // Send the buffered messages first - this->transport ()->send_buffered_messages (); - // Mark the entry as invalid this->transport ()->mark_invalid (); @@ -225,23 +205,13 @@ int TAO_UIOP_Connection_Handler::handle_timeout (const ACE_Time_Value &, const void *) { - // This method is called when buffering timer expires. - // - ACE_Time_Value *max_wait_time = 0; - - TAO_Stub *stub = 0; - int has_timeout; - this->orb_core ()->call_timeout_hook (stub, - has_timeout, - *max_wait_time); - // Cannot deal with errors, and therefore they are ignored. - this->transport ()->send_buffered_messages (max_wait_time); + if (this->transport ()->handle_output () == -1) + return -1; return 0; } - int TAO_UIOP_Connection_Handler::add_transport_to_cache (void) { diff --git a/TAO/tao/Strategies/UIOP_Transport.cpp b/TAO/tao/Strategies/UIOP_Transport.cpp index 9dbb2bd0019..172ef5260a0 100644 --- a/TAO/tao/Strategies/UIOP_Transport.cpp +++ b/TAO/tao/Strategies/UIOP_Transport.cpp @@ -5,10 +5,6 @@ #if TAO_HAS_UIOP == 1 - -ACE_RCSID (Strategies, UIOP_Transport, "$Id$") - - #include "UIOP_Connection_Handler.h" #include "UIOP_Profile.h" #include "tao/Timeprobe.h" @@ -26,6 +22,7 @@ ACE_RCSID (Strategies, UIOP_Transport, "$Id$") # include "UIOP_Transport.i" #endif /* ! __ACE_INLINE__ */ +ACE_RCSID (Strategies, UIOP_Transport, "$Id$") TAO_UIOP_Transport::TAO_UIOP_Transport (TAO_UIOP_Connection_Handler *handler, @@ -67,16 +64,17 @@ TAO_UIOP_Transport::messaging_object (void) return this->messaging_object_; } - ssize_t -TAO_UIOP_Transport::send_i (const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time, - size_t *bytes_transferred) +TAO_UIOP_Transport::send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *max_wait_time) { - return ACE::send_n (this->connection_handler_->get_handle (), - message_block, - max_wait_time, - bytes_transferred); + ssize_t retval = this->connection_handler_->peer ().sendv (iov, iovcnt, + max_wait_time); + if (retval > 0) + bytes_transferred = retval; + + return retval; } ssize_t @@ -127,6 +125,21 @@ TAO_UIOP_Transport::read_process_message (ACE_Time_Value *max_wait_time, int TAO_UIOP_Transport::register_handler_i (void) { + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - IIOP_Transport::register_handler %d\n", + this->id ())); + } + if (this->connection_handler_->is_registered ()) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - IIOP_Transport::register_handler %d" + ", already registered\n", + this->id ())); + return 0; + } + // @@ It seems like this method should go away, the right reactor is // picked at object creation time. ACE_Reactor *r = this->orb_core_->reactor (); @@ -180,7 +193,7 @@ TAO_UIOP_Transport::send_message (TAO_OutputCDR &stream, // versions seem to need it though. Leaving it costs little. // This guarantees to send all data (bytes) or return an error. - ssize_t n = this->send_or_buffer (stub, + ssize_t n = this->send_message_i (stub, twoway, stream.begin (), max_wait_time); @@ -196,17 +209,6 @@ TAO_UIOP_Transport::send_message (TAO_OutputCDR &stream, return -1; } - // EOF. - if (n == 0) - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t|%N|%l) send_message () \n") - ACE_TEXT ("EOF, closing transport %d\n"), - this->id ())); - return -1; - } - return 1; } diff --git a/TAO/tao/Strategies/UIOP_Transport.h b/TAO/tao/Strategies/UIOP_Transport.h index de7d68b2e1e..f3bb0b2b920 100644 --- a/TAO/tao/Strategies/UIOP_Transport.h +++ b/TAO/tao/Strategies/UIOP_Transport.h @@ -1,13 +1,13 @@ // This may look like C, but it's really -*- C++ -*- -// + // =================================================================== /** * @file UIOP_Transport.h * * $Id$ * - * @author Originally by Fred Kuhns <fredk@cs.wustl.edu> and Ossama - * Othman <ossama@ece.uci.edu> + * @author Originally by Fred Kuhns <fredk@cs.wustl.edu> + * @author Ossama Othman <ossama@ece.uci.edu> * @author Modified by Balachandran Natarajan <bala@cs.wustl.edu> */ // =================================================================== @@ -72,9 +72,9 @@ protected: virtual TAO_Pluggable_Messaging *messaging_object (void); /// Write the complete Message_Block chain to the connection. - virtual ssize_t send_i (const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0, - size_t *bytes_transferred = 0); + virtual ssize_t send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *timeout = 0); /// Read len bytes from into buf. virtual ssize_t recv_i (char *buf, diff --git a/TAO/tao/Sync_Strategies.cpp b/TAO/tao/Sync_Strategies.cpp index d09bcd1a5a5..a64223da662 100644 --- a/TAO/tao/Sync_Strategies.cpp +++ b/TAO/tao/Sync_Strategies.cpp @@ -5,138 +5,68 @@ #include "tao/Buffering_Constraint_Policy.h" #include "tao/Stub.h" #include "tao/ORB_Core.h" +#include "tao/debug.h" #if !defined (__ACE_INLINE__) # include "tao/Sync_Strategies.i" #endif /* ! __ACE_INLINE__ */ -TAO_Sync_Strategy::~TAO_Sync_Strategy (void) -{ -} +ACE_RCSID(tao, Sync_Strategies, "$Id$") -ssize_t -TAO_Transport_Sync_Strategy::send (TAO_Transport &transport, - TAO_Stub &, - const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time) +TAO_Sync_Strategy::~TAO_Sync_Strategy (void) { - // Immediate delegation to the transport. - return transport.send (message_block, - max_wait_time); } -#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) +// **************************************************************** -ssize_t -TAO_Delayed_Buffering_Sync_Strategy::send (TAO_Transport &transport, - TAO_Stub &stub, - const ACE_Message_Block *mb, - const ACE_Time_Value *max_wait_time) +int +TAO_Transport_Sync_Strategy:: + must_queue (int) { - ACE_Message_Block *message_block = - ACE_const_cast (ACE_Message_Block *, mb); - - ssize_t result = 0; - - // Get the message queue from the transport. - TAO_Transport_Buffering_Queue &buffering_queue = - transport.buffering_queue (); - - // Check if there are messages already in the queue. - if (!buffering_queue.is_empty ()) - return TAO_Eager_Buffering_Sync_Strategy::send (transport, - stub, - message_block, - max_wait_time); - - // - // Otherwise there were no queued messages. We first try to send - // the message right away. - // - - // Actual network send. - size_t bytes_transferred = 0; - result = transport.send (message_block, - max_wait_time, - &bytes_transferred); - - // Cannot send completely: timed out. - if (result == -1 && - errno == ETIME) - { - if (bytes_transferred > 0) - { - // If successful in sending some of the data, reset the - // message block appropriately. - transport.reset_sent_message (message_block, - bytes_transferred); - } - - // Queue the rest. - return bytes_transferred + - TAO_Eager_Buffering_Sync_Strategy::send (transport, - stub, - message_block, - max_wait_time); - } - - // EOF or other errors. - if (result == -1 || - result == 0) - return -1; - - // Everything was successfully delivered. - return result; + return 0; } -ssize_t -TAO_Eager_Buffering_Sync_Strategy::send (TAO_Transport &transport, - TAO_Stub &stub, - const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time) +int +TAO_Transport_Sync_Strategy:: + buffering_constraints_reached (TAO_Stub *, + size_t , + size_t , + int &must_flush, + const ACE_Time_Value &, + int &set_timer, + ACE_Time_Value &) { - ssize_t result = 0; - - // Get the message queue from the transport. - TAO_Transport_Buffering_Queue &buffering_queue = - transport.buffering_queue (); - - // Copy the message. - ACE_Message_Block *copy = message_block->clone (); - - // Enqueue current message. - result = buffering_queue.enqueue_tail (copy); - - // Enqueuing error. - if (result == -1) - { - // Eliminate the copy. - copy->release (); + set_timer = 0; + must_flush = 1; + return 1; +} - // Return error. - return -1; - } +#if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) - // Check if upper bound has been reached. - if (this->buffering_constraints_reached (transport, - stub, - buffering_queue)) - { - return transport.send_buffered_messages (max_wait_time); - } +// **************************************************************** - // Hoping that this return value is meaningful or at least - // acceptable. - return message_block->total_length (); +int +TAO_Eager_Buffering_Sync_Strategy:: + must_queue (int) +{ + return 1; } int -TAO_Eager_Buffering_Sync_Strategy::buffering_constraints_reached (TAO_Transport &transport, - TAO_Stub &stub, - TAO_Transport_Buffering_Queue &buffering_queue) +TAO_Eager_Buffering_Sync_Strategy:: + buffering_constraints_reached (TAO_Stub *stub, + size_t msg_count, + size_t total_bytes, + int &must_flush, + const ACE_Time_Value ¤t_deadline, + int &set_timer, + ACE_Time_Value &new_deadline) { + must_flush = 0; + set_timer = 0; + TAO_Buffering_Constraint_Policy *buffering_constraint_policy = - stub.buffering_constraint (); + stub->buffering_constraint (); if (buffering_constraint_policy == 0) return 1; @@ -147,80 +77,85 @@ TAO_Eager_Buffering_Sync_Strategy::buffering_constraints_reached (TAO_Transport TAO::BufferingConstraint buffering_constraint; buffering_constraint_policy->get_buffering_constraint (buffering_constraint); - this->timer_check (transport, - buffering_constraint); - if (buffering_constraint.mode == TAO::BUFFER_FLUSH) - return 1; + { + must_flush = 1; + return 1; + } + int constraints_reached = 0; if (ACE_BIT_ENABLED (buffering_constraint.mode, - TAO::BUFFER_MESSAGE_COUNT) && - buffering_queue.message_count () >= buffering_constraint.message_count) - return 1; + TAO::BUFFER_MESSAGE_COUNT) + && msg_count >= buffering_constraint.message_count) + constraints_reached = 1; if (ACE_BIT_ENABLED (buffering_constraint.mode, - TAO::BUFFER_MESSAGE_BYTES) && - buffering_queue.message_length () >= buffering_constraint.message_bytes) - return 1; + TAO::BUFFER_MESSAGE_BYTES) + && total_bytes >= buffering_constraint.message_bytes) + constraints_reached = 1; - return 0; + if (this->timer_check (buffering_constraint, + current_deadline, + set_timer, + new_deadline) != 0) + constraints_reached = 1; + + return constraints_reached; } -void -TAO_Eager_Buffering_Sync_Strategy::timer_check (TAO_Transport &transport, - const TAO::BufferingConstraint &buffering_constraint) +int +TAO_Eager_Buffering_Sync_Strategy:: + timer_check (const TAO::BufferingConstraint &buffering_constraint, + const ACE_Time_Value ¤t_deadline, + int &set_timer, + ACE_Time_Value &new_deadline) { - if (transport.buffering_timer_id () != 0) + set_timer = 0; + if (!ACE_BIT_ENABLED (buffering_constraint.mode, + TAO::BUFFER_TIMEOUT)) { - // - // There is a timeout set by us, though we are not sure if we - // still need the timeout or if the timeout value is correct or - // not. - // - - // Get our reactor. - ACE_Reactor *reactor = transport.orb_core ()->reactor (); - - if (!ACE_BIT_ENABLED (buffering_constraint.mode, - TAO::BUFFER_TIMEOUT)) - { - // Timeouts are no longer needed. Cancel existing one. - reactor->cancel_timer (transport.buffering_timer_id ()); - transport.buffering_timer_id (0); - } - else - { - ACE_Time_Value timeout = - this->time_conversion (buffering_constraint.timeout); - - if (transport.buffering_timeout_value () == timeout) - { - // Timeout value is the same, nothing to be done. - } - else - { - // Timeout value has changed, reset the old timer. - reactor->reset_timer_interval (transport.buffering_timer_id (), - timeout); - } - } + return 0; } - else if (ACE_BIT_ENABLED (buffering_constraint.mode, - TAO::BUFFER_TIMEOUT)) + + // Compute the next deadline... + ACE_Time_Value now = ACE_OS::gettimeofday (); + ACE_Time_Value timeout = + this->time_conversion (buffering_constraint.timeout); + new_deadline = now + timeout; + + // Check if the new deadline is more stringent, or if the deadline + // has expired and thus must be reset anyway. + if (current_deadline > new_deadline + || current_deadline < now) { - // We didn't have timeouts before, but we want them now. - ACE_Time_Value timeout = - this->time_conversion (buffering_constraint.timeout); + set_timer = 1; + } - long timer_id = transport.register_for_timer_event (0, timeout, timeout); + // ... if there is no deadline we don't want to schedule output (the + // deadline will be set because set_timer is set to 1 in that case). + // If there is a deadline but but it has not been reached, we + // don't want to schedule any output either... + if (current_deadline == ACE_Time_Value::zero + || current_deadline >= now) + { + return 0; + } - transport.buffering_timer_id (timer_id); - transport.buffering_timeout_value (timeout); + if (TAO_debug_level > 6) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - TAO_Eager_Buffering_Sync_Strategy::timer_check, " + "Now = %u, Current = %u, New = %u\n", + now.msec (), current_deadline.msec (), + new_deadline.msec ())); } + + return 1; } ACE_Time_Value -TAO_Eager_Buffering_Sync_Strategy::time_conversion (const TimeBase::TimeT &time) +TAO_Eager_Buffering_Sync_Strategy:: + time_conversion (const TimeBase::TimeT &time) { TimeBase::TimeT seconds = time / 10000000u; TimeBase::TimeT microseconds = (time % 10000000u) / 10; @@ -228,4 +163,14 @@ TAO_Eager_Buffering_Sync_Strategy::time_conversion (const TimeBase::TimeT &time) ACE_U64_TO_U32 (microseconds)); } +// **************************************************************** + +int +TAO_Delayed_Buffering_Sync_Strategy:: + must_queue (int queue_empty) +{ + // If the queue is empty we want to send immediately + return !queue_empty; +} + #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ diff --git a/TAO/tao/Sync_Strategies.h b/TAO/tao/Sync_Strategies.h index 5b273dac3e5..dcbc524a5a7 100644 --- a/TAO/tao/Sync_Strategies.h +++ b/TAO/tao/Sync_Strategies.h @@ -27,24 +27,61 @@ #include "tao/Transport.h" #include "tao/TAOC.h" +/// Define the interface for the Queueing Strategy +/** + * The low-level I/O components in the ORB use this strategy to + * determine when messages must be queued, immediately sent or + * flushed. + * + * The strategy isolates this low-level components from the higher + * level strategies used by the application developer. + * + * @todo The class name (Sync_Strategy) is inherited from the policies + * (SyncScopePolicy), but Queueing_Strategy probably captures its + * intent better. It should be changed in a future revision of the + * ORB. + */ class TAO_Export TAO_Sync_Strategy { public: + /// Destructor virtual ~TAO_Sync_Strategy (void); - virtual ssize_t send (TAO_Transport &transport, - TAO_Stub &stub, - const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time) = 0; + /// Return 1 if a message must be queued + virtual int must_queue (int queue_empty) = 0; + + /// Return 1 if it is time to start + /** + * @param stub The object used to make the request, this is used to + * obtain the policies currently in effect for the request + * @param msg_count The number of messages currently queued + * @param total_bytes Number of bytes currently queued + * @param set_timer Returns 1 if a timer should be set to drain the + * queue + * @param interval If set_timer returns 1, this parameter contains + * the timer interval + */ + virtual int buffering_constraints_reached (TAO_Stub *stub, + size_t msg_count, + size_t total_bytes, + int &must_flush, + const ACE_Time_Value ¤t_deadline, + int &set_timer, + ACE_Time_Value &interval) = 0; }; class TAO_Export TAO_Transport_Sync_Strategy : public TAO_Sync_Strategy { public: - ssize_t send (TAO_Transport &transport, - TAO_Stub &stub, - const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time); + virtual int must_queue (int queue_empty); + + virtual int buffering_constraints_reached (TAO_Stub *stub, + size_t msg_count, + size_t total_bytes, + int &must_flush, + const ACE_Time_Value ¤t_deadline, + int &set_timer, + ACE_Time_Value &interval); }; #if (TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1) @@ -52,28 +89,48 @@ public: class TAO_Export TAO_Eager_Buffering_Sync_Strategy : public TAO_Sync_Strategy { public: - ssize_t send (TAO_Transport &transport, - TAO_Stub &stub, - const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time); - - virtual int buffering_constraints_reached (TAO_Transport &transport, - TAO_Stub &stub, - TAO_Transport_Buffering_Queue &buffering_queue); - - void timer_check (TAO_Transport &transport, - const TAO::BufferingConstraint &buffering_constraint); - + virtual int must_queue (int queue_empty); + + virtual int buffering_constraints_reached (TAO_Stub *stub, + size_t msg_count, + size_t total_bytes, + int &must_flush, + const ACE_Time_Value ¤t_deadline, + int &set_timer, + ACE_Time_Value &new_deadline); + +private: + /// Check if the buffering constraint includes any timeouts and + /// compute the right timeout interval if needed. + /** + * @param buffering_constraint The constraints defined by the + * application + * @param set_timer Return 1 if the timer should be set + * @param interval Return the timer interval value + * + * @return Returns 1 if the deadline has already expired and + * flushing must commence immediately. If the function + * returns 0 then flushing may need to be delayed, use @c + * set_timer and + * + */ + int timer_check (const TAO::BufferingConstraint &buffering_constraint, + const ACE_Time_Value ¤t_deadline, + int &set_timer, + ACE_Time_Value &new_deadline); + + /// Convert from standard CORBA time units to seconds/microseconds. ACE_Time_Value time_conversion (const TimeBase::TimeT &time); }; +/// Delay the buffering decision until the transport blocks +/** + * If the queue is empty the transport will try to send immediately. + */ class TAO_Export TAO_Delayed_Buffering_Sync_Strategy : public TAO_Eager_Buffering_Sync_Strategy { public: - ssize_t send (TAO_Transport &transport, - TAO_Stub &stub, - const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time); + virtual int must_queue (int queue_empty); }; #endif /* TAO_HAS_BUFFERING_CONSTRAINT_POLICY == 1 */ diff --git a/TAO/tao/Synch_Queued_Message.cpp b/TAO/tao/Synch_Queued_Message.cpp new file mode 100644 index 00000000000..b65fd572408 --- /dev/null +++ b/TAO/tao/Synch_Queued_Message.cpp @@ -0,0 +1,91 @@ +// -*- C++ -*- +// $Id$ + +#include "Synch_Queued_Message.h" + +ACE_RCSID(tao, Synch_Queued_Message, "$Id$") + +TAO_Synch_Queued_Message:: + TAO_Synch_Queued_Message (const ACE_Message_Block *contents) + : contents_ (ACE_const_cast (ACE_Message_Block*,contents)) + , current_block_ (contents_) +{ +} + +TAO_Synch_Queued_Message::~TAO_Synch_Queued_Message (void) +{ +} + +const ACE_Message_Block * +TAO_Synch_Queued_Message::current_block (void) const +{ + return this->current_block_; +} + +size_t +TAO_Synch_Queued_Message::message_length (void) const +{ + if (this->current_block_ == 0) + return 0; + return this->current_block_->total_length (); +} + +int +TAO_Synch_Queued_Message::all_data_sent (void) const +{ + return this->current_block_ == 0; +} + +void +TAO_Synch_Queued_Message::fill_iov (int iovcnt_max, + int &iovcnt, + iovec iov[]) const +{ + ACE_ASSERT (iovcnt_max > iovcnt); + + for (const ACE_Message_Block *message_block = this->current_block_; + message_block != 0 && iovcnt < iovcnt_max; + message_block = message_block->cont ()) + { + size_t message_block_length = message_block->length (); + + // Check if this block has any data to be sent. + if (message_block_length > 0) + { + // Collect the data in the iovec. + iov[iovcnt].iov_base = message_block->rd_ptr (); + iov[iovcnt].iov_len = message_block_length; + + // Increment iovec counter. + iovcnt++; + } + } +} + +void +TAO_Synch_Queued_Message::bytes_transferred (size_t &byte_count) +{ + while (this->current_block_ != 0 && byte_count > 0) + { + size_t l = this->current_block_->length (); + + if (byte_count < l) + { + this->current_block_->rd_ptr (byte_count); + byte_count = 0; + return; + } + byte_count -= l; + this->current_block_ = this->current_block_->cont (); + while (this->current_block_ != 0 + && this->current_block_->length () == 0) + { + this->current_block_ = this->current_block_->cont (); + } + } +} + +void +TAO_Synch_Queued_Message::destroy (void) +{ +} diff --git a/TAO/tao/Synch_Queued_Message.h b/TAO/tao/Synch_Queued_Message.h new file mode 100644 index 00000000000..2a8c638abf7 --- /dev/null +++ b/TAO/tao/Synch_Queued_Message.h @@ -0,0 +1,86 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Synch_Queued_Message.h + * + * $Id$ + * + * @author Carlos O'Ryan <coryan@uci.edu> + */ +//============================================================================= + +#ifndef TAO_SYNCH_QUEUED_MESSAGE_H +#define TAO_SYNCH_QUEUED_MESSAGE_H +#include "ace/pre.h" + +#include "Queued_Message.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +/** + * @class TAO_Synch_Queued_Message + * + * @brief Specialize TAO_Queued_Message for synchronous requests, + * i.e. twoways and oneways sent with reliability better than + * SYNC_NONE. + * + * Reliable requests block the sending thread until the message is + * sent, likewise, the sending thread must be informed if the + * connection is closed or the message times out. + * + * In contrast oneway (and AMI) requests sent with the SYNC_NONE + * policy are simple discarded if the connection fails or they + * timeout. + * + * Another important difference is the management of the data buffer: + * one SYNC_NONE messages the buffer is immediately copied into a + * newly allocated buffer, and must be deallocated. Other types of + * requests use the memory allocated by the sending thread. + * + */ +class TAO_Export TAO_Synch_Queued_Message : public TAO_Queued_Message +{ +public: + /// Constructor + /** + * @param contents The message block chain that must be sent. + */ + TAO_Synch_Queued_Message (const ACE_Message_Block *contents); + + /// Destructor + virtual ~TAO_Synch_Queued_Message (void); + + const ACE_Message_Block *current_block (void) const; + + /** Implement the Template Methods from TAO_Queued_Message + */ + //@{ + virtual size_t message_length (void) const; + virtual int all_data_sent (void) const; + virtual void fill_iov (int iovcnt_max, int &iovcnt, iovec iov[]) const; + virtual void bytes_transferred (size_t &byte_count); + virtual void destroy (void); + //@} + +private: + /// The contents of the message. + /** + * The message is normally generated by a TAO_OutputCDR stream. The + * application marshals the payload, possibly generating a chain of + * message block connected via the 'cont()' field. + */ + ACE_Message_Block *contents_; + + /// The current message block + /** + * The message may be set in multiple writev() operations. This + * point keeps track of the next message to send out. + */ + ACE_Message_Block *current_block_; +}; + +#include "ace/post.h" +#endif /* TAO_QUEUED_MESSAGE_H */ diff --git a/TAO/tao/TAO.dsp b/TAO/tao/TAO.dsp index 196cf082a9f..e1ae786dc73 100644 --- a/TAO/tao/TAO.dsp +++ b/TAO/tao/TAO.dsp @@ -187,6 +187,10 @@ SOURCE=.\Asynch_Invocation.cpp # End Source File
# Begin Source File
+SOURCE=.\Asynch_Queued_Message.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Asynch_Reply_Dispatcher.cpp
# End Source File
# Begin Source File
@@ -207,6 +211,10 @@ SOURCE=.\Bind_Dispatcher_Guard.cpp # End Source File
# Begin Source File
+SOURCE=.\Block_Flushing_Strategy.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\BoundsC.cpp
# End Source File
# Begin Source File
@@ -363,6 +371,10 @@ SOURCE=.\FILE_Parser.cpp # End Source File
# Begin Source File
+SOURCE=.\Flushing_Strategy.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\GIOP_Message_Base.cpp
# End Source File
# Begin Source File
@@ -659,6 +671,14 @@ SOURCE=.\Protocols_Hooks.cpp # End Source File
# Begin Source File
+SOURCE=.\Queued_Message.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Reactive_Flushing_Strategy.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Reactor_Registry.cpp
# End Source File
# Begin Source File
@@ -703,10 +723,6 @@ SOURCE=.\RT_ORB.cpp # End Source File
# Begin Source File
-SOURCE=.\Thread_Pool.cpp
-# End Source File
-# Begin Source File
-
SOURCE=.\RT_ORB_Loader.cpp
# End Source File
# Begin Source File
@@ -775,6 +791,10 @@ SOURCE=.\Sync_Strategies.cpp # End Source File
# Begin Source File
+SOURCE=.\Synch_Queued_Message.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Synch_Reply_Dispatcher.cpp
# End Source File
# Begin Source File
@@ -807,6 +827,10 @@ SOURCE=.\target_specification.cpp # End Source File
# Begin Source File
+SOURCE=.\Thread_Pool.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\TimeBaseC.cpp
# End Source File
# Begin Source File
@@ -831,6 +855,10 @@ SOURCE=.\Transport_Mux_Strategy.cpp # End Source File
# Begin Source File
+SOURCE=.\Transport_Timer.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Typecode.cpp
# End Source File
# Begin Source File
@@ -907,6 +935,10 @@ SOURCE=.\Asynch_Invocation.h # End Source File
# Begin Source File
+SOURCE=.\Asynch_Queued_Message.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Asynch_Reply_Dispatcher.h
# End Source File
# Begin Source File
@@ -919,10 +951,18 @@ SOURCE=.\Base_Transport_Property.h # End Source File
# Begin Source File
+SOURCE=.\BiDir_Adapter.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Bind_Dispatcher_Guard.h
# End Source File
# Begin Source File
+SOURCE=.\Block_Flushing_Strategy.h
+# End Source File
+# Begin Source File
+
SOURCE=.\BoundsC.h
# End Source File
# Begin Source File
@@ -1091,6 +1131,10 @@ SOURCE=.\FILE_Parser.h # End Source File
# Begin Source File
+SOURCE=.\Flushing_Strategy.h
+# End Source File
+# Begin Source File
+
SOURCE=.\giop.h
# End Source File
# Begin Source File
@@ -1427,6 +1471,18 @@ SOURCE=.\Protocols_Hooks.h # End Source File
# Begin Source File
+SOURCE=.\Queued_Message.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Queued_Message.inl
+# End Source File
+# Begin Source File
+
+SOURCE=.\Reactive_Flushing_Strategy.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Reactor_Registry.h
# End Source File
# Begin Source File
@@ -1471,10 +1527,6 @@ SOURCE=.\RT_ORB.h # End Source File
# Begin Source File
-SOURCE=.\Thread_Pool.h
-# End Source File
-# Begin Source File
-
SOURCE=.\RT_ORB_Loader.h
# End Source File
# Begin Source File
@@ -1555,6 +1607,10 @@ SOURCE=.\Sync_Strategies.h # End Source File
# Begin Source File
+SOURCE=.\Synch_Queued_Message.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Synch_Reply_Dispatcher.h
# End Source File
# Begin Source File
@@ -1603,6 +1659,10 @@ SOURCE=.\target_specification.h # End Source File
# Begin Source File
+SOURCE=.\Thread_Pool.h
+# End Source File
+# Begin Source File
+
SOURCE=.\TimeBaseC.h
# End Source File
# Begin Source File
@@ -1639,6 +1699,10 @@ SOURCE=.\Transport_Mux_Strategy.h # End Source File
# Begin Source File
+SOURCE=.\Transport_Timer.h
+# End Source File
+# Begin Source File
+
SOURCE=.\try_macros.h
# End Source File
# Begin Source File
@@ -2123,10 +2187,6 @@ SOURCE=.\RT_ORB.i # End Source File
# Begin Source File
-SOURCE=.\Thread_Pool.i
-# End Source File
-# Begin Source File
-
SOURCE=.\RT_Policy_i.i
# End Source File
# Begin Source File
diff --git a/TAO/tao/TAO_Static.dsp b/TAO/tao/TAO_Static.dsp index e5a71d7c0e1..e2b4c9f35de 100644 --- a/TAO/tao/TAO_Static.dsp +++ b/TAO/tao/TAO_Static.dsp @@ -40,8 +40,8 @@ RSC=rc.exe # PROP Output_Dir ""
# PROP Intermediate_Dir "LIB\Release"
# PROP Target_Dir ""
-LINK32=link.exe -lib
MTL=midl.exe
+LINK32=link.exe -lib
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../" /I "../" /D "_WINDOWS" /D "_CONSOLE" /D "NDEBUG" /D "WIN32" /D "TAO_AS_STATIC_LIBS" /D "ACE_AS_STATIC_LIBS" /FD /c
# SUBTRACT CPP /YX
@@ -66,8 +66,8 @@ LIB32=link.exe -lib # PROP Output_Dir ""
# PROP Intermediate_Dir "LIB\Debug"
# PROP Target_Dir ""
-LINK32=link.exe -lib
MTL=midl.exe
+LINK32=link.exe -lib
# ADD BASE CPP /nologo /W3 /GX /Z7 /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /c
# ADD CPP /nologo /MDd /W3 /GX /Zi /Od /I "../../" /I "../" /D "_WINDOWS" /D "_CONSOLE" /D "_DEBUG" /D "WIN32" /D "ACE_AS_STATIC_LIBS" /D "TAO_AS_STATIC_LIBS" /FD /c
# SUBTRACT CPP /YX
@@ -119,6 +119,10 @@ SOURCE=.\Asynch_Invocation.h # End Source File
# Begin Source File
+SOURCE=.\Asynch_Queued_Message.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Asynch_Reply_Dispatcher.h
# End Source File
# Begin Source File
@@ -131,7 +135,19 @@ SOURCE=.\Base_Transport_Property.h # End Source File
# Begin Source File
-SOURCE=.\BiDir_Adapter.h
+SOURCE=.\BiDir_ORBInitializer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\BiDir_Policy_i.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\BiDir_PolicyFactory.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\BiDirPolicyC.h
# End Source File
# Begin Source File
@@ -139,6 +155,10 @@ SOURCE=.\Bind_Dispatcher_Guard.h # End Source File
# Begin Source File
+SOURCE=.\Block_Flushing_Strategy.h
+# End Source File
+# Begin Source File
+
SOURCE=.\BoundsC.h
# End Source File
# Begin Source File
@@ -275,10 +295,6 @@ SOURCE=.\Endpoint.h # End Source File
# Begin Source File
-SOURCE=.\Endpoint_Selector_Factory.h
-# End Source File
-# Begin Source File
-
SOURCE=.\Environment.h
# End Source File
# Begin Source File
@@ -299,6 +315,10 @@ SOURCE=.\FILE_Parser.h # End Source File
# Begin Source File
+SOURCE=.\Flushing_Strategy.h
+# End Source File
+# Begin Source File
+
SOURCE=.\giop.h
# End Source File
# Begin Source File
@@ -451,6 +471,10 @@ SOURCE=.\marshal.h # End Source File
# Begin Source File
+SOURCE=.\Message_Sent_Callback.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Messaging_ORBInitializer.h
# End Source File
# Begin Source File
@@ -631,6 +655,14 @@ SOURCE=.\Protocols_Hooks.h # End Source File
# Begin Source File
+SOURCE=.\Queued_Message.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Reactive_Flushing_Strategy.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Reactor_Registry.h
# End Source File
# Begin Source File
@@ -659,10 +691,6 @@ SOURCE=.\RT_Current.h # End Source File
# Begin Source File
-SOURCE=.\RT_Endpoint_Selector_Factory.h
-# End Source File
-# Begin Source File
-
SOURCE=.\RT_Invocation_Endpoint_Selectors.h
# End Source File
# Begin Source File
@@ -675,10 +703,6 @@ SOURCE=.\RT_ORB.h # End Source File
# Begin Source File
-SOURCE=.\Thread_Pool.h
-# End Source File
-# Begin Source File
-
SOURCE=.\RT_ORB_Loader.h
# End Source File
# Begin Source File
@@ -759,6 +783,10 @@ SOURCE=.\Sync_Strategies.h # End Source File
# Begin Source File
+SOURCE=.\Synch_Queued_Message.h
+# End Source File
+# Begin Source File
+
SOURCE=.\Synch_Reply_Dispatcher.h
# End Source File
# Begin Source File
@@ -911,6 +939,14 @@ SOURCE=.\Base_Transport_Property.inl # End Source File
# Begin Source File
+SOURCE=.\BiDir_Policy_i.inl
+# End Source File
+# Begin Source File
+
+SOURCE=.\BiDirPolicyC.i
+# End Source File
+# Begin Source File
+
SOURCE=.\Bind_Dispatcher_Guard.i
# End Source File
# Begin Source File
@@ -1163,6 +1199,10 @@ SOURCE=.\marshal.i # End Source File
# Begin Source File
+SOURCE=.\Message_Sent_Callback.inl
+# End Source File
+# Begin Source File
+
SOURCE=.\Messaging_Policy_i.i
# End Source File
# Begin Source File
@@ -1299,6 +1339,10 @@ SOURCE=.\Profile.i # End Source File
# Begin Source File
+SOURCE=.\Queued_Message.inl
+# End Source File
+# Begin Source File
+
SOURCE=.\Reactor_Registry.i
# End Source File
# Begin Source File
@@ -1323,10 +1367,6 @@ SOURCE=.\RT_ORB.i # End Source File
# Begin Source File
-SOURCE=.\Thread_Pool.i
-# End Source File
-# Begin Source File
-
SOURCE=.\RT_Policy_i.i
# End Source File
# Begin Source File
@@ -1511,6 +1551,10 @@ SOURCE=.\Asynch_Invocation.cpp # End Source File
# Begin Source File
+SOURCE=.\Asynch_Queued_Message.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Asynch_Reply_Dispatcher.cpp
# End Source File
# Begin Source File
@@ -1523,7 +1567,19 @@ SOURCE=.\Base_Transport_Property.cpp # End Source File
# Begin Source File
-SOURCE=.\BiDir_Adapter.cpp
+SOURCE=.\BiDir_ORBInitializer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\BiDir_Policy_i.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\BiDir_PolicyFactory.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\BiDirPolicyC.cpp
# End Source File
# Begin Source File
@@ -1531,6 +1587,10 @@ SOURCE=.\Bind_Dispatcher_Guard.cpp # End Source File
# Begin Source File
+SOURCE=.\Block_Flushing_Strategy.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\BoundsC.cpp
# End Source File
# Begin Source File
@@ -1659,10 +1719,6 @@ SOURCE=.\Endpoint.cpp # End Source File
# Begin Source File
-SOURCE=.\Endpoint_Selector_Factory.cpp
-# End Source File
-# Begin Source File
-
SOURCE=.\Environment.cpp
# End Source File
# Begin Source File
@@ -1683,6 +1739,10 @@ SOURCE=.\FILE_Parser.cpp # End Source File
# Begin Source File
+SOURCE=.\Flushing_Strategy.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\GIOP_Message_Base.cpp
# End Source File
# Begin Source File
@@ -1819,6 +1879,10 @@ SOURCE=.\Marshal.cpp # End Source File
# Begin Source File
+SOURCE=.\Message_Sent_Callback.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Messaging_ORBInitializer.cpp
# End Source File
# Begin Source File
@@ -1979,6 +2043,14 @@ SOURCE=.\Protocols_Hooks.cpp # End Source File
# Begin Source File
+SOURCE=.\Queued_Message.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Reactive_Flushing_Strategy.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Reactor_Registry.cpp
# End Source File
# Begin Source File
@@ -2007,10 +2079,6 @@ SOURCE=.\RT_Current.cpp # End Source File
# Begin Source File
-SOURCE=.\RT_Endpoint_Selector_Factory.cpp
-# End Source File
-# Begin Source File
-
SOURCE=.\RT_Invocation_Endpoint_Selectors.cpp
# End Source File
# Begin Source File
@@ -2023,10 +2091,6 @@ SOURCE=.\RT_ORB.cpp # End Source File
# Begin Source File
-SOURCE=.\Thread_Pool.cpp
-# End Source File
-# Begin Source File
-
SOURCE=.\RT_ORB_Loader.cpp
# End Source File
# Begin Source File
@@ -2095,6 +2159,10 @@ SOURCE=.\Sync_Strategies.cpp # End Source File
# Begin Source File
+SOURCE=.\Synch_Queued_Message.cpp
+# End Source File
+# Begin Source File
+
SOURCE=.\Synch_Reply_Dispatcher.cpp
# End Source File
# Begin Source File
diff --git a/TAO/tao/Transport.cpp b/TAO/tao/Transport.cpp index 32733dee5c5..d0755e59eef 100644 --- a/TAO/tao/Transport.cpp +++ b/TAO/tao/Transport.cpp @@ -12,8 +12,13 @@ #include "Sync_Strategies.h" #include "Connection_Handler.h" #include "Pluggable_Messaging.h" +#include "Synch_Queued_Message.h" +#include "Asynch_Queued_Message.h" +#include "Flushing_Strategy.h" #include "debug.h" +#include "ace/Message_Block.h" + #if !defined (__ACE_INLINE__) # include "Transport.inl" #endif /* __ACE_INLINE__ */ @@ -58,9 +63,12 @@ TAO_Transport::TAO_Transport (CORBA::ULong tag, , tag_ (tag) , orb_core_ (orb_core) , cache_map_entry_ (0) - , buffering_queue_ (0) - , buffering_timer_id_ (0) , bidirectional_flag_ (-1) + , head_ (0) + , tail_ (0) + , current_deadline_ (ACE_Time_Value::zero) + , flush_timer_id_ (-1) + , transport_timer_ (this) , id_ ((long) this) { TAO_Client_Strategy_Factory *cf = @@ -85,31 +93,76 @@ TAO_Transport::~TAO_Transport (void) delete this->tms_; this->tms_ = 0; - delete this->buffering_queue_; - delete this->handler_lock_; -} + TAO_Queued_Message *i = this->head_; + while (i != 0) + { + // @@ This is a good point to insert a flag to indicate that a + // CloseConnection message was successfully received. + i->connection_closed (); + TAO_Queued_Message *tmp = i; + i = i->next (); -ssize_t -TAO_Transport::send_or_buffer (TAO_Stub *stub, - int two_way, - const ACE_Message_Block *message_block, - const ACE_Time_Value *max_wait_time) + tmp->destroy (); + } +} + +int +TAO_Transport::handle_output () { + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::handle_output\n", + this->id ())); + } - if (stub == 0 || two_way) + // The flushing strategy (potentially via the Reactor) wants to send + // more data, first check if there is a current message that needs + // more sending... + int retval = this->drain_queue (); + + if (TAO_debug_level > 4) { - return this->send (message_block, max_wait_time); + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::handle_output, " + "drain_queue returns %d/%d\n", + this->id (), + retval, errno)); } - TAO_Sync_Strategy &sync_strategy = stub->sync_strategy (); + if (retval == 1) + { + // ... there is no current message or it was completely + // sent, cancel output... + TAO_Flushing_Strategy *flushing_strategy = + this->orb_core ()->flushing_strategy (); + + ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->handler_lock_, -1)); + + flushing_strategy->cancel_output (this); - return sync_strategy.send (*this, - *stub, - message_block, - max_wait_time); + if (this->flush_timer_id_ != -1) + { + ACE_Event_Handler *eh = this->event_handler_i (); + if (eh != 0) + { + ACE_Reactor *reactor = eh->reactor (); + if (reactor != 0) + { + (void) reactor->cancel_timer (this->flush_timer_id_); + } + } + this->current_deadline_ = ACE_Time_Value::zero; + this->flush_timer_id_ = -1; + } + return 0; + } + + // Any errors are returned directly to the Reactor + return retval; } void @@ -124,150 +177,342 @@ TAO_Transport::provide_handle (ACE_Handle_Set &handle_set) handle_set.set_bit (eh->get_handle ()); } -ssize_t -TAO_Transport::send_buffered_messages (const ACE_Time_Value *max_wait_time) +static void +dump_iov (iovec *iov, int iovcnt, int id, + size_t current_transfer, + const char *location) { - // Make sure we have a buffering queue and there are messages in it. - if (this->buffering_queue_ == 0 || - this->buffering_queue_->is_empty ()) - return 1; + ACE_Log_Msg::instance ()->acquire (); - // Now, we can take the lock and try to do something. - // - // @@CJC We might be able to reduce the length of time we hold - // the lock depending on whether or not we need to hold the - // hold the lock while we're doing queueing activities. - ACE_MT (ACE_GUARD_RETURN (ACE_Lock, - guard, - *this->handler_lock_, - -1)); + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::%s" + " sending %d buffers\n", + id, location, iovcnt)); + for (int i = 0; i != iovcnt && 0 < current_transfer; ++i) + { + size_t iov_len = iov[i].iov_len; + + // Possibly a partially sent iovec entry. + if (current_transfer < iov_len) + iov_len = current_transfer; + + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::%s" + " buffer %d/%d has %d bytes\n", + id, location, + i, iovcnt, + iov_len)); + + size_t len; + for (size_t offset = 0; offset < iov_len; offset += len) + { + char header[1024]; + ACE_OS::sprintf (header, + "TAO - Transport[%d]::%s (%d/%d)\n", + id, location, offset, iov_len); + + len = iov_len - offset; + if (len > 512) + len = 512; + ACE_HEX_DUMP ((LM_DEBUG, + ACE_static_cast(char*,iov[i].iov_base) + offset, + len, + header)); + } + current_transfer -= iov_len; + } + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::%s" + " end of data\n", + id, location)); + + ACE_Log_Msg::instance ()->release (); +} + +int +TAO_Transport::send_message_block_chain (const ACE_Message_Block *mb, + size_t &bytes_transferred, + ACE_Time_Value *max_wait_time) +{ + ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->handler_lock_, -1); + + if (this->check_event_handler_i ("TAO_Transport::send_message_block_chain") == -1) + return -1; + + return this->send_message_block_chain_i (mb, + bytes_transferred, + max_wait_time); +} + +int +TAO_Transport::send_message_block_chain_i (const ACE_Message_Block *mb, + size_t &bytes_transferred, + ACE_Time_Value *) +{ + size_t total_length = mb->total_length (); + + // We are going to block, so there is no need to clone + // the message block. + TAO_Synch_Queued_Message synch_message (mb); + + synch_message.push_back (this->head_, this->tail_); + + int n = this->drain_queue_i (); + if (n == -1) + { + synch_message.remove_from_list (this->head_, this->tail_); + ACE_ASSERT (synch_message.next () == 0); + ACE_ASSERT (synch_message.prev () == 0); + return -1; // Error while sending... + } + else if (n == 1) + { + ACE_ASSERT (synch_message.all_data_sent ()); + ACE_ASSERT (synch_message.next () == 0); + ACE_ASSERT (synch_message.prev () == 0); + return 1; // Empty queue, message was sent.. + } + + ACE_ASSERT (n == 0); // Some data sent, but data remains. + + // Remove the temporary message from the queue... + synch_message.remove_from_list (this->head_, this->tail_); + + bytes_transferred = + total_length - synch_message.message_length (); + + return 0; +} + +int +TAO_Transport::send_message_i (TAO_Stub *stub, + int is_synchronous, + const ACE_Message_Block *message_block, + ACE_Time_Value *max_wait_time) +{ + ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->handler_lock_, -1); + + if (this->check_event_handler_i ("TAO_Transport::send_message_i") == -1) + return -1; + + if (is_synchronous) + { + return this->send_synchronous_message_i (message_block, + max_wait_time); + } + + // Let's figure out if the message should be queued without trying + // to send first: + int try_sending_first = 1; + + int queue_empty = (this->head_ == 0); - // Get the first message from the queue. - ACE_Message_Block *queued_message = 0; - ssize_t result = this->buffering_queue_->peek_dequeue_head (queued_message); + if (!queue_empty) + try_sending_first = 0; + else if (stub->sync_strategy ().must_queue (queue_empty)) + try_sending_first = 0; - // @@ What to do here on failures? - ACE_ASSERT (result != -1); + size_t byte_count = 0; + ssize_t n; - // @@CJC take lock?? - // Actual network send. - size_t bytes_transferred = 0; - result = this->send_i (queued_message, - max_wait_time, - &bytes_transferred); - // @@CJC release lock?? + TAO_Flushing_Strategy *flushing_strategy = + this->orb_core ()->flushing_strategy (); - // Cannot send completely: timed out. - if (result == -1 && - errno == ETIME) + if (try_sending_first) { - if (bytes_transferred > 0) + // ... in this case we must try to send the message first ... + + if (TAO_debug_level > 6) { - // If successful in sending some of the data, reset the - // queue appropriately. - this->reset_queued_message (queued_message, - bytes_transferred); + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::send_message_i, " + "trying to send the message\n", + this->id ())); + } - // Indicate some success. - return bytes_transferred; + // @@ I don't think we want to hold the mutex here, however if + // we release it we need to recheck the status of the transport + // after we return... once I understand the final form for this + // code I will re-visit this decision + n = this->send_message_block_chain_i (message_block, + byte_count, + max_wait_time); + if (n == 0) + return -1; // EOF + else if (n == -1) + { + // ... if this is just an EWOULDBLOCK we must schedule the + // message for later, if it is ETIME we still have to send + // the complete message, because cutting off the message at + // this point will destroy the synchronization with the + // server ... + if (errno != EWOULDBLOCK && errno != ETIME) + { + return -1; + } } - // Since we queue up the message, this is not an error. We can - // try next time around. - return 1; + // ... let's figure out if the complete message was sent ... + if (message_block->total_length () == byte_count) + { + // Done, just return. Notice that there are no allocations + // or copies up to this point (though some fancy calling + // back and forth). + // This is the common case for the critical path, it should + // be fast. + return 0; + } } - // EOF or other errors. - if (result == -1 || - result == 0) + // ... either the message must be queued or we need to queue it + // because it was not completely sent out ... + + if (TAO_debug_level > 6) { - this->dequeue_all (); - return -1; + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::send_message_i, " + "message is queued\n", + this->id ())); } - // If successful in sending data, reset the queue appropriately. - this->reset_queued_message (queued_message, - bytes_transferred); + TAO_Queued_Message *queued_message = 0; + ACE_NEW_RETURN (queued_message, + TAO_Asynch_Queued_Message (message_block), + -1); + queued_message->bytes_transferred (byte_count); + queued_message->push_back (this->head_, this->tail_); + + // ... if the queue is full we need to activate the output on the + // queue ... + int must_flush = 0; + int constraints_reached = + this->check_buffering_constraints_i (stub, + must_flush); + + // ... but we also want to activate it if the message was partially + // sent.... Plus, when we use the blocking flushing strategy the + // queue is flushed as a side-effect of 'schedule_output()' + + if (constraints_reached || try_sending_first) + { + (void) flushing_strategy->schedule_output (this); + } - // Everything was successfully delivered. - return result; -} + if (must_flush) + { + typedef ACE_Reverse_Lock<ACE_Lock> TAO_REVERSE_LOCK; + TAO_REVERSE_LOCK reverse (*this->handler_lock_); + ACE_GUARD_RETURN (TAO_REVERSE_LOCK, ace_mon, reverse, -1); -void -TAO_Transport::reset_sent_message (ACE_Message_Block *message_block, - size_t bytes_delivered) -{ - this->reset_message (message_block, - bytes_delivered, - 0); -} + (void) flushing_strategy->flush_transport (this); + } -void -TAO_Transport::reset_queued_message (ACE_Message_Block *message_block, - size_t bytes_delivered) -{ - this->reset_message (message_block, - bytes_delivered, - 1); + return 0; } -void -TAO_Transport::reset_message (ACE_Message_Block *message_block, - size_t bytes_delivered, - int queued_message) +int +TAO_Transport::send_synchronous_message_i (const ACE_Message_Block *mb, + ACE_Time_Value *max_wait_time) { - while (bytes_delivered != 0) - { - // Our current message block chain. - ACE_Message_Block *current_message_block = message_block; + // We are going to block, so there is no need to clone + // the message block. + TAO_Synch_Queued_Message synch_message (mb); - int completely_delivered_current_message_block_chain = 0; + synch_message.push_back (this->head_, this->tail_); - while (current_message_block != 0 && - bytes_delivered != 0) - { - size_t current_message_block_length = - current_message_block->length (); + int n = this->drain_queue_i (); + if (n == -1) + { + synch_message.remove_from_list (this->head_, this->tail_); + ACE_ASSERT (synch_message.next () == 0); + ACE_ASSERT (synch_message.prev () == 0); + return -1; // Error while sending... + } + else if (n == 1) + { + ACE_ASSERT (synch_message.all_data_sent ()); + ACE_ASSERT (synch_message.next () == 0); + ACE_ASSERT (synch_message.prev () == 0); + return 1; // Empty queue, message was sent.. + } - int completely_delivered_current_message_block = - bytes_delivered >= current_message_block_length; + ACE_ASSERT (n == 0); // Some data sent, but data remains. - size_t adjustment_size = - ACE_MIN (current_message_block_length, bytes_delivered); + if (synch_message.all_data_sent ()) + { + ACE_ASSERT (synch_message.next () == 0); + ACE_ASSERT (synch_message.prev () == 0); + return 1; + } - // Reset according to send size. - current_message_block->rd_ptr (adjustment_size); + // @todo: Check for timeouts! + // if (max_wait_time != 0 && errno == ETIME) return -1; - // If queued message, adjust the queue. - if (queued_message) - // Hand adjust <message_length>. - this->buffering_queue_->message_length ( - this->buffering_queue_->message_length () - adjustment_size); + TAO_Flushing_Strategy *flushing_strategy = + this->orb_core ()->flushing_strategy (); + (void) flushing_strategy->schedule_output (this); - // Adjust <bytes_delivered>. - bytes_delivered -= adjustment_size; + // Release the mutex, other threads may modify the queue as we + // block for a long time writing out data. + int result; + { + typedef ACE_Reverse_Lock<ACE_Lock> TAO_REVERSE_LOCK; + TAO_REVERSE_LOCK reverse (*this->handler_lock_); + ACE_GUARD_RETURN (TAO_REVERSE_LOCK, ace_mon, reverse, -1); - if (completely_delivered_current_message_block) + result = flushing_strategy->flush_message (this, + &synch_message, + max_wait_time); + } + if (result == -1) + { + synch_message.remove_from_list (this->head_, this->tail_); + if (errno == ETIME) + { + if (this->head_ == &synch_message) { - // Next message block in the continuation chain. - current_message_block = current_message_block->cont (); - - if (current_message_block == 0) - completely_delivered_current_message_block_chain = 1; + // This is a timeout, there is only one nasty case: the + // message has been partially sent! We simply cannot take + // the message out of the queue, because that would corrupt + // the connection. + // + // What we do is replace the queued message with an + // asynchronous message, that contains only what remains of + // the timed out request. If you think about sending + // CancelRequests in this case: there is no much point in + // doing that: the receiving ORB would probably ignore it, + // and figuring out the request ID would be a bit of a + // nightmare. + // + + synch_message.remove_from_list (this->head_, this->tail_); + TAO_Queued_Message *queued_message = 0; + ACE_NEW_RETURN (queued_message, + TAO_Asynch_Queued_Message ( + synch_message.current_block ()), + -1); + queued_message->push_front (this->head_, this->tail_); } } - if (completely_delivered_current_message_block_chain) + if (TAO_debug_level > 0) { - // Go to the next message block chain. - message_block = message_block->next (); - - // If queued message, adjust the queue. - if (queued_message) - // Release this <current_message_block>. - this->dequeue_head (); + ACE_ERROR ((LM_ERROR, + "TAO (%P|%t) TAO_Transport::send_synchronous_message_i, " + "error while flushing message %p\n", "")); } + + return -1; } + + else + { + ACE_ASSERT (synch_message.all_data_sent () != 0); + } + + ACE_ASSERT (synch_message.next () == 0); + ACE_ASSERT (synch_message.prev () == 0); + return 1; } int @@ -320,14 +565,6 @@ TAO_Transport::connection_handler_closing (void) TAO_Transport::release(this); } -#if 0 -TAO_Connection_Handler* -TAO_Transport::connection_handler (void) const -{ - return 0; -} -#endif - TAO_Transport* TAO_Transport::_duplicate (TAO_Transport* transport) { @@ -377,9 +614,6 @@ TAO_Transport::mark_invalid (void) // @@ Do we need this method at all?? this->orb_core_->transport_cache ().mark_invalid ( this->cache_map_entry_); - - - } int @@ -429,32 +663,28 @@ TAO_Transport::close_connection (void) // work, for some reason they hold the mutex while they do // that work though. this->orb_core_->transport_cache ().purge_entry (this->cache_map_entry_); + + for (TAO_Queued_Message *i = this->head_; i != 0; i = i->next ()) + { + i->connection_closed (); + } } ssize_t -TAO_Transport::send (const ACE_Message_Block *mblk, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) +TAO_Transport::send (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *timeout) { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, guard, *this->handler_lock_, -1)); - // if there's no associated event handler, then we act like a null transport - if (this->event_handler_i () == 0) - { - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t) transport %d (tag=%d) send() ") - ACE_TEXT ("no longer associated with handler, returning -1 with errno = ENOENT\n"), - this->id (), - this->tag_)); - errno = ENOENT; - return -1; - } + if (this->check_event_handler_i ("TAO_Transport::send") == -1) + return -1; // now call the template method - return this->send_i (mblk, timeout, bytes_transferred); + return this->send_i (iov, iovcnt, bytes_transferred, timeout); } ssize_t @@ -467,18 +697,8 @@ TAO_Transport::recv (char *buffer, *this->handler_lock_, -1)); - // if there's no associated event handler, then we act like a null transport - if (this->event_handler_i () == 0) - { - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t) transport %d (tag=%d) recv() ") - ACE_TEXT ("no longer associated with handler, returning -1 with errno = ENOENT\n"), - this->id (), - this->tag_)); - // @@CJC Should we return -1, like an error, or should we return 0, like an EOF? - errno = ENOENT; - return -1; - } + if (this->check_event_handler_i ("TAO_Transport::recv") == -1) + return -1; // now call the template method return this->recv_i (buffer, len, timeout); @@ -546,6 +766,19 @@ TAO_Transport::register_for_timer_event (const void* arg, } int +TAO_Transport::queue_is_empty (void) +{ + ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->handler_lock_, -1); + return this->queue_is_empty_i (); +} + +int +TAO_Transport::queue_is_empty_i (void) +{ + return (this->head_ == 0); +} + +int TAO_Transport::register_handler (void) { ACE_MT (ACE_GUARD_RETURN (ACE_Lock, @@ -566,3 +799,324 @@ TAO_Transport::id (int id) { this->id_ = id; } + +int +TAO_Transport::schedule_output_i (void) +{ + ACE_Event_Handler *eh = this->event_handler_i (); + if (eh == 0) + return -1; + + ACE_Reactor *reactor = eh->reactor (); + if (reactor == 0) + return -1; + + if (TAO_debug_level > 3) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::schedule_output\n", + this->id ())); + } + + return reactor->schedule_wakeup (eh, ACE_Event_Handler::WRITE_MASK); +} + +int +TAO_Transport::cancel_output_i (void) +{ + ACE_Event_Handler *eh = this->event_handler_i (); + if (eh == 0) + return -1; + + ACE_Reactor *reactor = eh->reactor (); + if (reactor == 0) + return -1; + + if (TAO_debug_level > 3) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - Transport[%d]::cancel output\n", + this->id ())); + } + + return reactor->cancel_wakeup (eh, ACE_Event_Handler::WRITE_MASK); +} + +int +TAO_Transport::handle_timeout (const ACE_Time_Value & /* current_time */, + const void *act) +{ + /// This is the only legal ACT in the current configuration.... + if (act != &this->current_deadline_) + return -1; + + if (this->flush_timer_pending ()) + { + // The timer is always a oneshot timer, so mark is as not + // pending. + this->reset_flush_timer (); + + TAO_Flushing_Strategy *flushing_strategy = + this->orb_core ()->flushing_strategy (); + (void) flushing_strategy->schedule_output (this); + } + return 0; +} + +int +TAO_Transport::drain_queue (void) +{ + ACE_GUARD_RETURN (ACE_Lock, ace_mon, *this->handler_lock_, -1); + + return this->drain_queue_i (); +} + +int +TAO_Transport::drain_queue_helper (int &iovcnt, iovec iov[]) +{ + if (this->check_event_handler_i ("TAO_Transport::drain_queue_helper") == -1) + return -1; + + size_t byte_count = 0; + + // ... send the message ... + ssize_t retval = + this->send_i (iov, iovcnt, byte_count); + + if (TAO_debug_level == 5) + { + dump_iov (iov, iovcnt, this->id (), + byte_count, "drain_queue_helper"); + } + + // ... now we need to update the queue, removing elements + // that have been sent, and updating the last element if it + // was only partially sent ... + this->cleanup_queue (byte_count); + iovcnt = 0; + + if (retval == 0) + { + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - TAO_Transport::drain_queue_helper, " + "send() returns 0")); + } + return -1; + } + else if (retval == -1) + { + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - TAO_Transport::drain_queue_helper, " + "%p", "send()")); + } + if (errno == EWOULDBLOCK) + return 0; + return -1; + } + + // ... start over, how do we guarantee progress? Because if + // no bytes are sent send() can only return 0 or -1 + ACE_ASSERT (byte_count != 0); + + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - TAO_Transport::drain_queue_helper, " + "byte_count = %d, head_is_empty = %d\n", + byte_count, (this->head_ == 0))); + } + return 1; +} + +int +TAO_Transport::drain_queue_i (void) +{ + if (this->head_ == 0) + return 1; + + // This is the vector used to send data, it must be declared outside + // the loop because after the loop there may still be data to be + // sent + int iovcnt = 0; + iovec iov[IOV_MAX]; + + // We loop over all the elements in the queue ... + TAO_Queued_Message *i = this->head_; + while (i != 0) + { + // ... each element fills the iovector ... + i->fill_iov (IOV_MAX, iovcnt, iov); + + // ... the vector is full, no choice but to send some data out. + // We need to loop because a single message can span multiple + // IOV_MAX elements ... + if (iovcnt == IOV_MAX) + { + int retval = + this->drain_queue_helper (iovcnt, iov); + + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - TAO_Transport::drain_queue_i, " + "helper retval = %d\n", + retval)); + } + if (retval != 1) + return retval; + + i = this->head_; + continue; + } + // ... notice that this line is only reached if there is still + // room in the iovector ... + i = i->next (); + } + + + if (iovcnt != 0) + { + int retval = + this->drain_queue_helper (iovcnt, iov); + + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - TAO_Transport::drain_queue_i, " + "helper retval = %d\n", + retval)); + } + if (retval != 1) + return retval; + } + + if (this->head_ == 0) + return 1; + + return 0; +} + +void +TAO_Transport::cleanup_queue (size_t byte_count) +{ + while (this->head_ != 0 && byte_count > 0) + { + TAO_Queued_Message *i = this->head_; + + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - TAO_Transport::cleanup_queue, " + "byte_count = %d, head_is_empty = %d\n", + byte_count, (this->head_ == 0))); + } + + // Update the state of the first message + i->bytes_transferred (byte_count); + + if (TAO_debug_level > 4) + { + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t) - TAO_Transport::cleanup_queue, " + "after transfer, byte_count = %d, all_sent = %d\n", + byte_count, i->all_data_sent ())); + } + + // ... if all the data was sent the message must be removed from + // the queue... + if (i->all_data_sent ()) + { + i->remove_from_list (this->head_, this->tail_); + i->destroy (); + } + } +} + +int +TAO_Transport::check_buffering_constraints_i (TAO_Stub *stub, + int &must_flush) +{ + // First let's compute the size of the queue: + size_t msg_count = 0; + size_t total_bytes = 0; + for (TAO_Queued_Message *i = this->head_; i != 0; i = i->next ()) + { + msg_count++; + total_bytes += i->message_length (); + } + + int set_timer; + ACE_Time_Value new_deadline; + + int constraints_reached = + stub->sync_strategy ().buffering_constraints_reached (stub, + msg_count, + total_bytes, + must_flush, + this->current_deadline_, + set_timer, + new_deadline); + + // ... set the new timer, also cancel any previous timers ... + if (set_timer) + { + ACE_MT (ACE_GUARD_RETURN (ACE_Lock, + guard, + *this->handler_lock_, + -1)); + + ACE_Event_Handler *eh = this->event_handler_i (); + if (eh != 0) + { + ACE_Reactor *reactor = eh->reactor (); + if (reactor != 0) + { + this->current_deadline_ = new_deadline; + ACE_Time_Value delay = + new_deadline - ACE_OS::gettimeofday (); + + if (this->flush_timer_pending ()) + { + (void) reactor->cancel_timer (this->flush_timer_id_); + } + this->flush_timer_id_ = + reactor->schedule_timer (&this->transport_timer_, + &this->current_deadline_, + delay); + } + } + } + + return constraints_reached; +} + +void +TAO_Transport::report_invalid_event_handler (const char *caller) +{ + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) transport %d (tag=%d) %s " + "no longer associated with handler, " + "returning -1 with errno = ENOENT\n", + this->id (), + this->tag_, + caller)); + } +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) + +template class ACE_Reverse_Lock<ACE_Lock>; +template class ACE_Guard<ACE_Reverse_Lock<ACE_Lock> >; + +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + +#pragma instantiate ACE_Reverse_Lock<ACE_Lock> +#pragma instantiate ACE_Guard<ACE_Reverse_Lock<ACE_Lock> > + +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/tao/Transport.h b/TAO/tao/Transport.h index 00ca18315cf..f4ec1fefb62 100644 --- a/TAO/tao/Transport.h +++ b/TAO/tao/Transport.h @@ -9,7 +9,6 @@ * Define the interface for the Transport component in TAO's * pluggable protocol framework. * - * * @author Fred Kuhns <fredk@cs.wustl.edu> */ //============================================================================= @@ -23,6 +22,8 @@ #include "Exception.h" #include "Transport_Descriptor_Interface.h" #include "Transport_Cache_Manager.h" +#include "Transport_Timer.h" +#include "ace/Strategies.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once @@ -36,10 +37,7 @@ class TAO_Wait_Strategy; class TAO_Connection_Handler; class TAO_Pluggable_Messaging; -#include "ace/Message_Queue.h" -#include "ace/Strategies.h" - -typedef ACE_Message_Queue<ACE_NULL_SYNCH> TAO_Transport_Buffering_Queue; +class TAO_Queued_Message; class TAO_Export TAO_Synch_Refcountable : private ACE_Refcountable { @@ -57,7 +55,6 @@ protected: ACE_Lock *refcount_lock_; }; - /** * @class TAO_Transport * @@ -95,10 +92,10 @@ protected: * transport may already be sending another message in a reactive * fashion. * - * Consequently, the Transport must also keep a - * <TT>current_message</TT>, if the current message is not null any - * new messages must be queued. Only once the current message is - * completely sent we can take a message out of the queue. + * Consequently, the Transport must also know if the head of the queue + * has been partially sent. In that case new messages can only follow + * the head. Only once the head is completely sent we can start + * sending new messages. * * <H4>Waiting threads:</H4> One or more threads can be blocked * waiting for the connection to completely send the message. @@ -146,11 +143,6 @@ protected: */ class TAO_Export TAO_Transport : private TAO_Synch_Refcountable { - - friend class TAO_Transport_Sync_Strategy; - friend class TAO_Eager_Buffering_Sync_Strategy; - friend class TAO_Delayed_Buffering_Sync_Strategy; - public: /// default creator, requres the tag value be supplied. TAO_Transport (CORBA::ULong tag, @@ -193,26 +185,8 @@ public: */ TAO_Wait_Strategy *wait_strategy (void) const; - /// Send a request or queue it for later. - /** - * If the right policies are set queue the request for later. - * Otherwise, or if the queue size has reached the configured - * limits, start draining the queue. - * - * If any data is to be sent it blocks until the queue is completely - * drained. - * - * This method serializes on handler_lock_, guaranteeing that only - * thread can execute it on the same instance concurrently. - * - * @todo: this routine will probably go away as part of the - * reorganization to support non-blocking writes. - */ - // @@ lockme - ssize_t send_or_buffer (TAO_Stub *stub, - int two_way, - const ACE_Message_Block *mblk, - const ACE_Time_Value *s = 0); + /// Callback method to reactively drain the outgoing data queue + int handle_output (void); /** * Return the TSS leader follower condition variable used in the @@ -221,21 +195,6 @@ public: */ virtual TAO_SYNCH_CONDITION *leader_follower_condition_variable (void); - /// Queue for buffering transport messages. - virtual TAO_Transport_Buffering_Queue &buffering_queue (void); - - /// Timer id associated with buffering. - long buffering_timer_id (void) const; - void buffering_timer_id (long); - - /// Timeout value associated with buffering. - const ACE_Time_Value &buffering_timeout_value (void) const; - void buffering_timeout_value (const ACE_Time_Value &time); - - /// Send any messages that have been buffered. - // @@ lockme - ssize_t send_buffered_messages (const ACE_Time_Value *max_wait_time = 0); - /** * Initialising the messaging object. This would be used by the * connector side. On the acceptor side the connection handler @@ -252,7 +211,8 @@ public: /** * Called by the cache when the cache is closing in order to fill * in a handle_set in a lock-safe manner. - * @param handle_set the ACE_Handle_Set into which the transport should place any handle registered with the reactor + * @param handle_set the ACE_Handle_Set into which the transport + * should place any handle registered with the reactor */ void provide_handle (ACE_Handle_Set &handle_set); @@ -267,6 +227,12 @@ public: */ void dequeue_all (void); + /// Check if there are messages pending in the queue + /** + * @return 1 if the queue is empty + */ + int queue_is_empty (void); + /// Register the handler with the reactor. /** * This method is used by the Wait_On_Reactor strategy. The @@ -340,9 +306,9 @@ public: * down). In that case, it returns -1 and sets errno to * <code>ENOENT</code>. */ - ssize_t send (const ACE_Message_Block *mblk, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); + ssize_t send (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *timeout = 0); /// Read len bytes from into buf. /** @@ -433,9 +399,9 @@ protected: * bytes already on the OS I/O subsystem. * */ - virtual ssize_t send_i (const ACE_Message_Block *mblk, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0) = 0; + virtual ssize_t send_i (iovec *iov, int iovcnt, + size_t &bytes_transferred, + const ACE_Time_Value *timeout = 0) = 0; // Read len bytes from into buf. /** @@ -491,7 +457,7 @@ public: virtual int send_request (TAO_Stub *stub, TAO_ORB_Core *orb_core, TAO_OutputCDR &stream, - int twoway, + int is_synchronous, ACE_Time_Value *max_time_wait) = 0; @@ -509,7 +475,7 @@ public: // @@ lockme virtual int send_message (TAO_OutputCDR &stream, TAO_Stub *stub = 0, - int twoway = 1, + int is_synchronous = 1, ACE_Time_Value *max_time_wait = 0) = 0; /// Callback to read incoming data @@ -568,8 +534,6 @@ public: */ virtual int reactor_signalling (void); - //@} - /// Method for the connection handler to signify that it /// is being closed and destroyed. virtual void connection_handler_closing (void); @@ -577,14 +541,18 @@ public: /// Register the associated connection handler with the reactor /// for a timer. /** - * At this point, only <code>TAO_Eager_Buffering_Sync_Strategy::timer_check()</code> - * uses this, and it's unclear whether it needs to stay around. But, it's here - * because it uses the associated protocol-specific connection handler, and accesses - * to that must be serialized on the internal lock. - * - * @param arg argument passed to the handle_timeout() method of the event handler + * At this point, only + * <code>TAO_Eager_Buffering_Sync_Strategy::timer_check()</code> + * uses this, and it's unclear whether it needs to stay around. + * But, it's here because it uses the associated protocol-specific + * connection handler, and accesses to that must be serialized on + * the internal lock. + * + * @param arg argument passed to the handle_timeout() method of the + * event handler * @param delay time interval after which the timer will expire - * @param interval time interval after which the timer will be automatically rescheduled + * @param interval time interval after which the timer will be + * automatically rescheduled * @return -1 on failure, a Reactor timer_id value on success * * @see ACE_Reactor::schedule_timer() @@ -594,7 +562,6 @@ public: const ACE_Time_Value &delay, const ACE_Time_Value &interval = ACE_Time_Value::zero); - // Maintain reference counting with these static TAO_Transport* _duplicate (TAO_Transport* transport); static void release (TAO_Transport* transport); @@ -603,34 +570,145 @@ public: int recache_transport (TAO_Transport_Descriptor_Interface* desc); /// Set/Get the Cache Map entry - void cache_map_entry ( - TAO_Transport_Cache_Manager::HASH_MAP_ENTRY *entry); + void cache_map_entry (TAO_Transport_Cache_Manager::HASH_MAP_ENTRY *entry); + TAO_Transport_Cache_Manager::HASH_MAP_ENTRY *cache_map_entry (void); + + /// Send a message block chain, + int send_message_block_chain (const ACE_Message_Block *message_block, + size_t &bytes_transferred, + ACE_Time_Value *max_wait_time = 0); + /// Sent the contents of <message_block> + /** + * @todo This method name sucks, but send_message() was already + * taken by other silly methods! + * + * @param stub The object reference used for this operation, useful + * to obtain the current policies. + * @param is_synchronous If set this method will block until the + * operation is completely written on the wire + * @param message_block The CDR encapsulation of the GIOP message + * that must be sent. The message may consist of + * multiple Message Blocks chained through the cont() + * field. + * @param max_wait_time The maximum time that the operation can + * block, used in the implementation of timeouts. + * + */ + /// the twoway flag or by the current policies in the stub. + int send_message_i (TAO_Stub *stub, + int is_synchronous, + const ACE_Message_Block *message_block, + ACE_Time_Value *max_wait_time); + + /// Send a message block chain, assuming the lock is held + int send_message_block_chain_i (const ACE_Message_Block *message_block, + size_t &bytes_transferred, + ACE_Time_Value *max_wait_time); + /// Cache management void mark_invalid (void); + /// Cache management int make_idle (void); -protected: - // @@ see if one of these calls send_message() - /// Remove the first message from the outgoing queue. - void dequeue_head (void); + /// The timeout callback, invoked when any of the timers related to + /// this transport expire. + /** + * @param current_time The current time as reported from the Reactor + * @param act The Asynchronous Completion Token. Currently it is + * interpreted as follows: + * - If the ACT is the address of this->current_deadline_ the + * queueing timeout has expired and the queue should start + * flushing. + * + * @return Returns 0 if there are no problems, -1 if there is an + * error + * + * @todo In the future this function could be used to expire + * messages (oneways) that have been sitting for too long on + * the queue. + */ + int handle_timeout (const ACE_Time_Value ¤t_time, + const void* act); - /// Update the state of the outgoing queue, assuming that - /// bytes_delivered bytes have been sent already. - void reset_queued_message (ACE_Message_Block *message_block, - size_t bytes_delivered); +private: + /// Send some of the data in the queue. + /** + * As the outgoing data is drained this method is invoked to send as + * much of the current message as possible. + * + * Returns 0 if there is more data to send, -1 if there was an error + * and 1 if the message was completely sent. + */ + int drain_queue (void); - /// Update the state of the outgoing queue, this time a complete - /// message was sent. - void reset_sent_message (ACE_Message_Block *message_block, - size_t bytes_delivered); + /// Implement drain_queue() assuming the lock is held + int drain_queue_i (void); - /// Helper function used to implement the two methods above. - void reset_message (ACE_Message_Block *message_block, - size_t bytes_delivered, - int queued_message); + /// This class needs priviledged access to + /// - queue_is_empty_i() + /// - drain_queue_i() + friend class TAO_Block_Flushing_Strategy; + + /// Check if there are messages pending in the queue + /** + * This version assumes that the lock is already held. Use with + * care! + * + * @return 1 if the queue is empty + */ + int queue_is_empty_i (void); + + /// A helper routine used in drain_queue_i() + int drain_queue_helper (int &iovcnt, iovec iov[]); + + /// This class needs privileged access to: + /// - schedule_output_i() + /// - cancel_output_i() + friend class TAO_Reactive_Flushing_Strategy; + + /// Schedule handle_output() callbacks + int schedule_output_i (void); + + /// Cancel handle_output() callbacks + int cancel_output_i (void); + + /// Cleanup the queue. + /** + * Exactly <byte_count> bytes have been sent, the queue must be + * cleaned up as potentially several messages have been completely + * sent out. + * It leaves on head_ the next message to send out. + */ + void cleanup_queue (size_t byte_count); + + /// Copy the contents of a message block into a Queued_Message + /// TAO_Queued_Message *copy_message_block (const ACE_Message_Block *mb); + + /// Check if the buffering constraints have been reached + int check_buffering_constraints_i (TAO_Stub *stub, int &must_flush); + + /// Send a synchronous message, i.e. block until the message is on + /// the wire + int send_synchronous_message_i (const ACE_Message_Block *message_block, + ACE_Time_Value *max_wait_time); + + /// Check if the flush timer is still pending + int flush_timer_pending (void) const; + + /// The flush timer expired or was explicitly cancelled, mark it as + /// not pending + void reset_flush_timer (void); + + /// Check if the underlying event handler is still valid. + /** + * @return Returns -1 if not, 0 if it is. + */ + int check_event_handler_i (const char *caller); + + /// Print out error messages if the event handler is not valid + void report_invalid_event_handler (const char *caller); -private: /// Prohibited ACE_UNIMPLEMENTED_FUNC (TAO_Transport (const TAO_Transport&)) ACE_UNIMPLEMENTED_FUNC (void operator= (const TAO_Transport&)) @@ -653,15 +731,6 @@ protected: /// Strategy for waiting for the reply after sending the request. TAO_Wait_Strategy *ws_; - /// Queue for buffering transport messages. - TAO_Transport_Buffering_Queue *buffering_queue_; - - /// Buffering timer id. - long buffering_timer_id_; - - /// Buffering timeout value. - ACE_Time_Value buffering_timeout_value_; - /// Use to check if bidirectional info has been synchronized with /// the peer. /** @@ -683,6 +752,20 @@ protected: */ int bidirectional_flag_; + /// Implement the outgoing data queue + TAO_Queued_Message *head_; + TAO_Queued_Message *tail_; + + /// The queue will start draining no later than <queing_deadline_> + /// *if* the deadline is + ACE_Time_Value current_deadline_; + + /// The timer ID + long flush_timer_id_; + + /// The adapter used to receive timeout callbacks from the Reactor + TAO_Transport_Timer transport_timer_; + /// Lock that insures that activities that *might* use handler-related /// resources (such as a connection handler) get serialized. /** diff --git a/TAO/tao/Transport.inl b/TAO/tao/Transport.inl index 48cbed6c5ac..48fac8f557c 100644 --- a/TAO/tao/Transport.inl +++ b/TAO/tao/Transport.inl @@ -1,7 +1,10 @@ // $Id$ - - +ACE_INLINE CORBA::ULong +TAO_Transport::tag (void) const +{ + return this->tag_; +} ACE_INLINE TAO_ORB_Core * TAO_Transport::orb_core (void) const @@ -22,97 +25,55 @@ TAO_Transport::wait_strategy (void) const return this->ws_; } -ACE_INLINE CORBA::ULong -TAO_Transport::tag (void) const -{ - return this->tag_; -} - -ACE_INLINE long -TAO_Transport::buffering_timer_id (void) const -{ - return this->buffering_timer_id_; -} - -ACE_INLINE void -TAO_Transport::buffering_timer_id (long new_value) -{ - this->buffering_timer_id_ = new_value; -} - -ACE_INLINE const ACE_Time_Value & -TAO_Transport::buffering_timeout_value (void) const +ACE_INLINE int +TAO_Transport::bidirectional_flag (void) const { - return this->buffering_timeout_value_; + return this->bidirectional_flag_; } ACE_INLINE void -TAO_Transport::buffering_timeout_value (const ACE_Time_Value &new_value) +TAO_Transport::bidirectional_flag (int flag) { - this->buffering_timeout_value_ = new_value; + this->bidirectional_flag_ = flag; } -ACE_INLINE TAO_Transport_Buffering_Queue & -TAO_Transport::buffering_queue (void) +/*ACE_INLINE TAO_Transport_Cache_Manager::HASH_MAP_ENTRY * +TAO_Transport::cache_map_entry (void) { - if (this->buffering_queue_ == 0) - { - // Infinite high water mark: ACE_UINT32_MAX. - this->buffering_queue_ = - new TAO_Transport_Buffering_Queue (ACE_UINT32_MAX); - } - - return *this->buffering_queue_; + return this->cache_map_entry_; } +*/ ACE_INLINE void -TAO_Transport::dequeue_head (void) +TAO_Transport::cache_map_entry ( + TAO_Transport_Cache_Manager::HASH_MAP_ENTRY *entry) { - // Remove from the head of the queue. - ACE_Message_Block *message_block = 0; - int result = this->buffering_queue_->dequeue_head (message_block); - - // @@ What to do here on failures? - ACE_ASSERT (result != -1); - ACE_UNUSED_ARG (result); - - // Release the memory. - message_block->release (); + this->cache_map_entry_ = entry; } ACE_INLINE int -TAO_Transport::bidirectional_flag (void) const +TAO_Transport::flush_timer_pending (void) const { - return this->bidirectional_flag_; + return this->flush_timer_id_ != -1; } ACE_INLINE void -TAO_Transport::bidirectional_flag (int flag) +TAO_Transport::reset_flush_timer (void) { - this->bidirectional_flag_ = flag; + this->flush_timer_id_ = -1; + this->current_deadline_ = ACE_Time_Value::zero; } -ACE_INLINE void -TAO_Transport::dequeue_all (void) +ACE_INLINE int +TAO_Transport::check_event_handler_i (const char *caller) { - // Flush all queued messages. - if (this->buffering_queue_) + // if there's no associated event handler, then we act like a null + // transport + if (this->event_handler_i () == 0) { - while (!this->buffering_queue_->is_empty ()) - this->dequeue_head (); + this->report_invalid_event_handler (caller); + errno = ENOENT; + return -1; } -} - -/*ACE_INLINE TAO_Transport_Cache_Manager::HASH_MAP_ENTRY * -TAO_Transport::cache_map_entry (void) -{ - return this->cache_map_entry_; -} -*/ - -ACE_INLINE void -TAO_Transport::cache_map_entry ( - TAO_Transport_Cache_Manager::HASH_MAP_ENTRY *entry) -{ - this->cache_map_entry_ = entry; + return 0; } diff --git a/TAO/tao/Transport_Timer.cpp b/TAO/tao/Transport_Timer.cpp new file mode 100644 index 00000000000..709a98414c8 --- /dev/null +++ b/TAO/tao/Transport_Timer.cpp @@ -0,0 +1,19 @@ +// -*- C++ -*- +// $Id$ + +#include "Transport_Timer.h" +#include "Transport.h" + +ACE_RCSID(tao, Transport_Timer, "$Id$") + +TAO_Transport_Timer::TAO_Transport_Timer (TAO_Transport *transport) + : transport_ (transport) +{ +} + +int +TAO_Transport_Timer::handle_timeout (const ACE_Time_Value ¤t_time, + const void *act) +{ + return this->transport_->handle_timeout (current_time, act); +} diff --git a/TAO/tao/Transport_Timer.h b/TAO/tao/Transport_Timer.h new file mode 100644 index 00000000000..e1e2d7b070c --- /dev/null +++ b/TAO/tao/Transport_Timer.h @@ -0,0 +1,54 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Transport_Timer.h + * + * $Id$ + * + * @author Carlos O'Ryan <coryan@uci.edu> + */ +//============================================================================= + +#ifndef TAO_TRANSPORT_TIMER_H +#define TAO_TRANSPORT_TIMER_H +#include "ace/pre.h" + +#include "TAO_Export.h" +#include "ace/Event_Handler.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class TAO_Transport; + +/** + * @class TAO_Transport_Timer + * + * @brief Allows TAO_Transport instances to receive timeout + * notifications from the Reactor. In other words, implements + * the Adapter Role, of the Adapter Pattern, where the Adaptee + * is a TAO_Transport and the client is the Reactor. + * + */ +class TAO_Export TAO_Transport_Timer : public ACE_Event_Handler +{ +public: + /// Constructor + /** + * @param transport The adaptee + */ + TAO_Transport_Timer (TAO_Transport *transport); + + /// Receive timeout events from the Reactor and forward them to the + /// TAO_Transport + virtual int handle_timeout (const ACE_Time_Value ¤t_time, + const void *act); +private: + /// The Adaptee + TAO_Transport *transport_; +}; + +#include "ace/post.h" +#endif /* TAO_TRANSPORT_TIMER_H */ diff --git a/TAO/tao/default_resource.cpp b/TAO/tao/default_resource.cpp index 2a74726468b..11232cc1182 100644 --- a/TAO/tao/default_resource.cpp +++ b/TAO/tao/default_resource.cpp @@ -11,6 +11,9 @@ #include "tao/Single_Reactor.h" #include "tao/Priority_Mapping.h" +#include "tao/Reactive_Flushing_Strategy.h" +#include "tao/Block_Flushing_Strategy.h" + #include "ace/TP_Reactor.h" #include "ace/Dynamic_Service.h" #include "ace/Arg_Shifter.h" @@ -33,6 +36,7 @@ TAO_Default_Resource_Factory::TAO_Default_Resource_Factory (void) reactor_mask_signals_ (1), dynamically_allocated_reactor_ (0), cached_connection_lock_type_ (TAO_THREAD_LOCK) + , flushing_strategy_type_ (TAO_REACTIVE_FLUSHING) { } @@ -194,6 +198,7 @@ TAO_Default_Resource_Factory::init (int argc, char **argv) this->add_to_ior_parser_names (argv[curarg]); } } + else if (ACE_OS::strcasecmp (argv[curarg], "-ORBConnectionCacheLock") == 0) { @@ -210,6 +215,7 @@ TAO_Default_Resource_Factory::init (int argc, char **argv) this->cached_connection_lock_type_ = TAO_NULL_LOCK; } } + else if (ACE_OS::strcasecmp (argv[curarg], "-ORBConnectionLock") == 0) { @@ -230,6 +236,7 @@ TAO_Default_Resource_Factory::init (int argc, char **argv) this->cached_connection_lock_type_ = TAO_NULL_LOCK; } } + else if (ACE_OS::strcasecmp (argv[curarg], "-ORBConnectorLock") == 0) { @@ -251,6 +258,23 @@ TAO_Default_Resource_Factory::init (int argc, char **argv) } } + else if (ACE_OS::strcasecmp (argv[curarg], + "-ORBFlushingStrategy") == 0) + { + curarg++; + if (curarg < argc) + { + char *name = argv[curarg]; + + if (ACE_OS::strcasecmp (name, + "reactive") == 0) + this->flushing_strategy_type_ = TAO_REACTIVE_FLUSHING; + else if (ACE_OS::strcasecmp (name, + "blocking") == 0) + this->flushing_strategy_type_ = TAO_BLOCKING_FLUSHING; + } + } + return 0; } @@ -705,6 +729,21 @@ TAO_Default_Resource_Factory::create_cached_connection_lock (void) return the_lock; } +TAO_Flushing_Strategy * +TAO_Default_Resource_Factory::create_flushing_strategy (void) +{ + TAO_Flushing_Strategy *strategy = 0; + if (this->flushing_strategy_type_ == TAO_REACTIVE_FLUSHING) + ACE_NEW_RETURN (strategy, + TAO_Reactive_Flushing_Strategy, + 0); + else + ACE_NEW_RETURN (strategy, + TAO_Block_Flushing_Strategy, + 0); + return strategy; +} + TAO_Priority_Mapping * TAO_Default_Resource_Factory::get_priority_mapping (void) { diff --git a/TAO/tao/default_resource.h b/TAO/tao/default_resource.h index 9df0760d36b..a976e5b285b 100644 --- a/TAO/tao/default_resource.h +++ b/TAO/tao/default_resource.h @@ -6,7 +6,8 @@ * * $Id$ * - * @author Chris CleelandCarlos O'Ryan + * @author Chris Cleeland + * @author Carlos O'Ryan */ //============================================================================= @@ -92,6 +93,7 @@ public: virtual double purge_percentage (void) const; virtual TAO_Priority_Mapping *get_priority_mapping (void); virtual ACE_Lock *create_cached_connection_lock (void); + virtual TAO_Flushing_Strategy *create_flushing_strategy (void); protected: /// Obtain the reactor implementation @@ -162,6 +164,15 @@ private: /// Type of lock used by the cached connector. Lock_Type cached_connection_lock_type_; + + enum Flushing_Strategy_Type + { + TAO_REACTIVE_FLUSHING, + TAO_BLOCKING_FLUSHING + }; + + /// Type of flushing strategy configured + int flushing_strategy_type_; }; #if defined (__ACE_INLINE__) diff --git a/TAO/tao/factories.h b/TAO/tao/factories.h deleted file mode 100644 index 5e9d5a0001f..00000000000 --- a/TAO/tao/factories.h +++ /dev/null @@ -1,146 +0,0 @@ -// This may look like C, but it's really -*- C++ -*- - -// ============================================================================ -// -// = LIBRARY -// TAO -// -// = FILENAME -// factories.h -// -// = AUTHOR -// Chris Cleeland -// -// = VERSION -// $Id$ -// ============================================================================ - -#ifndef TAO_FACTORIES_H -# define TAO_FACTORIES_H - -#if 0 -# include "ace/SOCK_Acceptor.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -# include "ace/SOCK_Connector.h" -# include "ace/Strategies_T.h" -# include "ace/Connector.h" -# include "ace/Synch.h" - -# include "tao/params.h" -# include "tao/connect.h" -# include "tao/objtable.h" -#endif - -class TAO_Client_Connection_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> - // = TITLE - // <Svc_Handler> used on the client side and returned - // by the <TAO_Client_Factory::CONNECTOR>. -{ -public: - TAO_Client_Connection_Handler (ACE_Thread_Manager* = 0); - // Do-nothing constructor - - virtual int open (void*); - // Initialization hook - - void in_use (CORBA::Boolean); - // Set the in-use flag. - - CORBA::Boolean in_use (void); - // Return state of the in-use flag. - -private: - CORBA::Boolean in_use_; - // True value indicates that something is using this handler. -}; - -class TAO_Client_Factory - // = TITLE - // Abstract factory used by the client to turn out various - // strategies used on the client side. -{ -public: - typedef ACE_Strategy_Connector<TAO_Client_Connection_Handler, ACE_SOCK_CONNECTOR> - CONNECTOR; - typedef ACE_NOOP_Creation_Strategy<TAO_Client_Connection_Handler> - NULL_CREATION_STRATEGY; - typedef ACE_Cached_Connect_Strategy<TAO_Client_Connection_Handler, - ACE_SOCK_CONNECTOR, - ACE_SYNCH_RW_MUTEX> - CACHED_CONNECT_STRATEGY; - -#if defined (TAO_HAS_CLIENT_CONCURRENCY) - CONCURRENCY_STRATEGY *concurrency_strategy (void); -#endif - - CONNECTOR *connector (void); - // Return a pointer to a connector using appropriate strategies. - - TAO_Client_Factory (void); - ~TAO_Client_Factory (void); - -private: -#if defined (TAO_HAS_CLIENT_CONCURRENCY) - CONCURRENCY_STRATEGY *concurrency_strategy_; -#endif - CONNECTOR connector_; - NULL_CREATION_STRATEGY null_creation_strategy_; - CACHED_CONNECT_STRATEGY caching_connect_strategy_; -}; - -class TAO_Server_Factory - // = TITLE - // Abstract factory used by the server side to turn out various - // strategies of special utility to it. -{ -public: - // = SERVER-SIDE - typedef ACE_Creation_Strategy<TAO_OA_Connection_Handler> CREATION_STRATEGY; - typedef ACE_Accept_Strategy<TAO_OA_Connection_Handler, ACE_SOCK_ACCEPTOR> ACCEPT_STRATEGY; - typedef ACE_Concurrency_Strategy<TAO_OA_Connection_Handler> CONCURRENCY_STRATEGY; - typedef ACE_Scheduling_Strategy<TAO_OA_Connection_Handler> SCHEDULING_STRATEGY; - - CREATION_STRATEGY *creation_strategy (void); - // return concrete creation strategy - - ACCEPT_STRATEGY *accept_strategy (void); - // return concrete acceptor strategy - - CONCURRENCY_STRATEGY *concurrency_strategy (void); - // return the concurrency strategy used - - SCHEDULING_STRATEGY *scheduling_strategy (void); - // return the scheduling strategy used - - TAO_Object_Table *object_lookup_strategy (void); - // return the concrete object lookup strategy - - TAO_Server_Factory (void); - // constructor - -private: - // = COMMON - ACE_Thread_Strategy<TAO_OA_Connection_Handler> threaded_strategy_; - // The threaded strategy used for passively establishing connections. - ACE_Reactive_Strategy<TAO_OA_Connection_Handler> reactive_strategy_; - // A strategy for passively establishing connections which utilizes the Reactor. - - // = SERVER - CONCURRENCY_STRATEGY *concurrency_strategy_; - // concrete concurrency strategy - - TAO_Object_Table *objtable_; - // instance of object table -#if 0 - // Someday we'll need these! - CREATION_STRATEGY *creation_strategy_; - ACCEPT_STRATEGY *accept_strategy_; - SCHEDULING_STRATEGY *scheduling_strategy_; -#endif -}; - -#endif /* TAO_FACTORIES_H */ diff --git a/TAO/tests/AMI/exclusive.conf b/TAO/tests/AMI/exclusive.conf index c78e5018593..b269154099f 100644 --- a/TAO/tests/AMI/exclusive.conf +++ b/TAO/tests/AMI/exclusive.conf @@ -1,2 +1,2 @@ -static Client_Strategy_Factory "-ORBTransportMuxStrategy EXCLUSIVE -ORBiiopprofilelock null -ORBclientconnectionhandler ST" +static Client_Strategy_Factory "-ORBTransportMuxStrategy EXCLUSIVE -ORBProfileLock null -ORBclientconnectionhandler ST" diff --git a/TAO/tests/AMI/muxed.conf b/TAO/tests/AMI/muxed.conf index 97bca811c1b..a7f2f5f608a 100644 --- a/TAO/tests/AMI/muxed.conf +++ b/TAO/tests/AMI/muxed.conf @@ -1,2 +1,2 @@ -static Client_Strategy_Factory "-ORBTransportMuxStrategy MUXED -ORBiiopprofilelock null -ORBclientconnectionhandler ST" +static Client_Strategy_Factory "-ORBTransportMuxStrategy MUXED -ORBProfileLock null -ORBClientConnectionHandler ST" diff --git a/TAO/tests/AMI/run_test.pl b/TAO/tests/AMI/run_test.pl index e1f43afa343..c4643c52be9 100755 --- a/TAO/tests/AMI/run_test.pl +++ b/TAO/tests/AMI/run_test.pl @@ -34,7 +34,7 @@ $SV = new PerlACE::Process ("server", $SV->Spawn (); -if (PerlACE::waitforfile_timed ($iorfile, 5) == -1) { +if (PerlACE::waitforfile_timed ($iorfile, 15) == -1) { print STDERR "ERROR: cannot find file <$iorfile>\n"; $SV->Kill (); $SV->TimedWait (1); exit 1; diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering.cpp b/TAO/tests/AMI_Buffering/AMI_Buffering.cpp new file mode 100644 index 00000000000..79a75408078 --- /dev/null +++ b/TAO/tests/AMI_Buffering/AMI_Buffering.cpp @@ -0,0 +1,41 @@ +// +// $Id$ +// +#include "AMI_Buffering.h" + +ACE_RCSID(AMI_Buffering, AMI_Buffering, "$Id$") + +AMI_Buffering::AMI_Buffering (CORBA::ORB_ptr orb, + Test::AMI_Buffering_Admin_ptr admin) + : orb_ (CORBA::ORB::_duplicate (orb)) + , admin_ (Test::AMI_Buffering_Admin::_duplicate (admin)) +{ +} + +void +AMI_Buffering::receive_data (const Test::Payload &the_payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->admin_->request_received (the_payload.length (), ACE_TRY_ENV); +} + +void +AMI_Buffering::flush (CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +AMI_Buffering::sync (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->admin_->flush (ACE_TRY_ENV); +} + +void +AMI_Buffering::shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0, ACE_TRY_ENV); +} diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering.dsw b/TAO/tests/AMI_Buffering/AMI_Buffering.dsw new file mode 100644 index 00000000000..68c39e32788 --- /dev/null +++ b/TAO/tests/AMI_Buffering/AMI_Buffering.dsw @@ -0,0 +1,53 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "AMI_Buffering Admin"=.\admin.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "AMI_Buffering Client"=.\client.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "AMI_Buffering Server"=.\server.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering.h b/TAO/tests/AMI_Buffering/AMI_Buffering.h new file mode 100644 index 00000000000..d3f672a97ba --- /dev/null +++ b/TAO/tests/AMI_Buffering/AMI_Buffering.h @@ -0,0 +1,55 @@ +// +// $Id$ +// + +#ifndef AMI_BUFFERING_H +#define AMI_BUFFERING_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::AMI_Buffering interface +class AMI_Buffering + : public virtual POA_Test::AMI_Buffering + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + AMI_Buffering (CORBA::ORB_ptr orb, + Test::AMI_Buffering_Admin_ptr admin); + + // = The skeleton methods + virtual void receive_data (const Test::Payload &the_payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void flush (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void sync (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Use an ORB reference to shutdown the application. + CORBA::ORB_var orb_; + + /// Report request progress to this interface + Test::AMI_Buffering_Admin_var admin_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* AMI_BUFFERING_H */ diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.cpp b/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.cpp new file mode 100644 index 00000000000..241e3d0b325 --- /dev/null +++ b/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.cpp @@ -0,0 +1,49 @@ +// +// $Id$ +// +#include "AMI_Buffering_Admin.h" + +ACE_RCSID(AMI_Buffering, AMI_Buffering_Admin, "$Id$") + +AMI_Buffering_Admin::AMI_Buffering_Admin (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) + , request_count_ (0) + , bytes_received_count_ (0) +{ +} + +CORBA::ULong +AMI_Buffering_Admin::request_count (CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->request_count_; +} + +CORBA::ULong +AMI_Buffering_Admin::bytes_received_count (CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->bytes_received_count_; +} + +void +AMI_Buffering_Admin::request_received (CORBA::ULong payload_length, + CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->request_count_++; + this->bytes_received_count_ += payload_length; +} + +void +AMI_Buffering_Admin::flush (CORBA::Environment &) + ACE_THROW_SPEC (()) +{ +} + +void +AMI_Buffering_Admin::shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0, ACE_TRY_ENV); +} diff --git a/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.h b/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.h new file mode 100644 index 00000000000..c586a32d8e0 --- /dev/null +++ b/TAO/tests/AMI_Buffering/AMI_Buffering_Admin.h @@ -0,0 +1,60 @@ +// +// $Id$ +// + +#ifndef AMI_BUFFERING_ADMIN_H +#define AMI_BUFFERING_ADMIN_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::AMI_Buffering_Admin interface +class AMI_Buffering_Admin + : public virtual POA_Test::AMI_Buffering_Admin + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + AMI_Buffering_Admin (CORBA::ORB_ptr orb); + + // = The skeleton methods + virtual CORBA::ULong request_count (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::ULong bytes_received_count (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void request_received (CORBA::ULong payload_length, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void flush (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC (()); + + virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Use an ORB reference to shutdown the application. + CORBA::ORB_var orb_; + + /// Keep track of the number of requests received + CORBA::ULong request_count_; + + /// Keep track of the number of requests received + CORBA::ULong bytes_received_count_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* AMI_BUFFERING_H */ diff --git a/TAO/tests/AMI_Buffering/Client_Task.cpp b/TAO/tests/AMI_Buffering/Client_Task.cpp new file mode 100644 index 00000000000..3c74d4aa262 --- /dev/null +++ b/TAO/tests/AMI_Buffering/Client_Task.cpp @@ -0,0 +1,48 @@ +// +// $Id$ +// + +#include "Client_Task.h" + +ACE_RCSID(AMI_Buffering, Client_Task, "$Id$") + +Client_Task::Client_Task (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) + , terminate_loop_ (0) +{ +} + +void +Client_Task::terminate_loop (void) +{ + ACE_GUARD (TAO_SYNCH_MUTEX, ace_mon, this->mutex_); + this->terminate_loop_ = 1; +} + +int +Client_Task::svc (void) +{ + ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting client task\n")); + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + while (1) + { + // run the even loop for 1 second... + ACE_Time_Value tv (1, 0); + this->orb_->run (tv, ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_GUARD_RETURN (TAO_SYNCH_MUTEX, ace_mon, this->mutex_, -1); + if (this->terminate_loop_ != 0) + break; + } + } + ACE_CATCHANY + { + return -1; + } + ACE_ENDTRY; + ACE_DEBUG ((LM_DEBUG, "(%P|%t) Client task finished\n")); + return 0; +} diff --git a/TAO/tests/AMI_Buffering/Client_Task.h b/TAO/tests/AMI_Buffering/Client_Task.h new file mode 100644 index 00000000000..1e41e68bdc9 --- /dev/null +++ b/TAO/tests/AMI_Buffering/Client_Task.h @@ -0,0 +1,42 @@ +// +// $Id$ +// + +#ifndef AMI_BUFFERING_CLIENT_TASK_H +#define AMI_BUFFERING_CLIENT_TASK_H +#include "ace/pre.h" + +#include "tao/corba.h" +#include "ace/Task.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +/// Implement a Task to run the experiments using multiple threads. +class Client_Task : public ACE_Task_Base +{ +public: + /// Constructor + Client_Task (CORBA::ORB_ptr orb); + + /// Terminate the loop + void terminate_loop (void); + + /// Thread entry point + int svc (void); + +private: + /// Reference to the ORB + CORBA::ORB_var orb_; + + /// A mutex, synchronize access to the termination flag + TAO_SYNCH_MUTEX mutex_; + + /// Termination flag, set to 1 when the client wants this task to + /// exit + int terminate_loop_; +}; + +#include "ace/post.h" +#endif /* AMI_BUFFERING_CLIENT_TASK_H */ diff --git a/TAO/tests/AMI_Buffering/Makefile b/TAO/tests/AMI_Buffering/Makefile new file mode 100644 index 00000000000..11a0556d9f3 --- /dev/null +++ b/TAO/tests/AMI_Buffering/Makefile @@ -0,0 +1,3218 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +IDL_FILES = Test +IDL_SRC = TestC.cpp TestS.cpp +BIN_UNCHECKED = admin server client + +SRC = $(addsuffix .cpp, \ + $(BIN_UNCHECKED) \ + Reply_Handler \ + Client_Task \ + AMI_Buffering \ + AMI_Buffering_Admin) $(IDL_SRC) + +CLIENT_OBJS = client.o Reply_Handler.o Client_Task.o $(IDL_SRC:.cpp=.o) +SERVER_OBJS = server.o AMI_Buffering.o $(IDL_SRC:.cpp=.o) +ADMIN_OBJS = admin.o AMI_Buffering_Admin.o $(IDL_SRC:.cpp=.o) + +TAO_IDLFLAGS += -Ge 1 -GC +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU + +ifeq ($(corba_messaging),1) +BIN=$(BIN_UNCHECKED) +endif # corba_messaging + +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), Test$(ext)) + +server: $(addprefix $(VDIR),$(SERVER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +admin: $(addprefix $(VDIR),$(ADMIN_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CLIENT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), Test$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/admin.o .obj/admin.o .obj/admin.o .obj/admin.o: admin.cpp AMI_Buffering_Admin.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(TAO_ROOT)/tao/TimeBaseS.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.h \ + $(TAO_ROOT)/tao/TimeBaseS_T.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ + $(TAO_ROOT)/tao/TimeBaseS.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.i \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Endpoint.i \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.inl \ + $(TAO_ROOT)/tao/Cache_Entries.inl \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.inl \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RT_Policy_i.i \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/Priority_Mapping.i \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Transport.h \ + $(TAO_ROOT)/tao/Transport_Timer.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(TAO_ROOT)/tao/Transport.inl \ + $(TAO_ROOT)/tao/Asynch_Timeout_Handler.h \ + $(TAO_ROOT)/tao/Messaging.h \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.i \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + TestC.i TestS_T.h TestS_T.i TestS_T.cpp TestS.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i + +.obj/server.o .obj/server.o .obj/server.o .obj/server.o: server.cpp AMI_Buffering.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(TAO_ROOT)/tao/TimeBaseS.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.h \ + $(TAO_ROOT)/tao/TimeBaseS_T.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ + $(TAO_ROOT)/tao/TimeBaseS.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.i \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Endpoint.i \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.inl \ + $(TAO_ROOT)/tao/Cache_Entries.inl \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.inl \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RT_Policy_i.i \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/Priority_Mapping.i \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Transport.h \ + $(TAO_ROOT)/tao/Transport_Timer.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(TAO_ROOT)/tao/Transport.inl \ + $(TAO_ROOT)/tao/Asynch_Timeout_Handler.h \ + $(TAO_ROOT)/tao/Messaging.h \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.i \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + TestC.i TestS_T.h TestS_T.i TestS_T.cpp TestS.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i + +.obj/client.o .obj/client.o .obj/client.o .obj/client.o: client.cpp Reply_Handler.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(TAO_ROOT)/tao/TimeBaseS.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.h \ + $(TAO_ROOT)/tao/TimeBaseS_T.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ + $(TAO_ROOT)/tao/TimeBaseS.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.i \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Endpoint.i \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.inl \ + $(TAO_ROOT)/tao/Cache_Entries.inl \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.inl \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RT_Policy_i.i \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/Priority_Mapping.i \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Transport.h \ + $(TAO_ROOT)/tao/Transport_Timer.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(TAO_ROOT)/tao/Transport.inl \ + $(TAO_ROOT)/tao/Asynch_Timeout_Handler.h \ + $(TAO_ROOT)/tao/Messaging.h \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.i \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + TestC.i TestS_T.h TestS_T.i TestS_T.cpp TestS.i Client_Task.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i + +.obj/Reply_Handler.o .obj/Reply_Handler.o .obj/Reply_Handler.o .obj/Reply_Handler.o: Reply_Handler.cpp Reply_Handler.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(TAO_ROOT)/tao/TimeBaseS.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.h \ + $(TAO_ROOT)/tao/TimeBaseS_T.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ + $(TAO_ROOT)/tao/TimeBaseS.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.i \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Endpoint.i \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.inl \ + $(TAO_ROOT)/tao/Cache_Entries.inl \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.inl \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RT_Policy_i.i \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/Priority_Mapping.i \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Transport.h \ + $(TAO_ROOT)/tao/Transport_Timer.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(TAO_ROOT)/tao/Transport.inl \ + $(TAO_ROOT)/tao/Asynch_Timeout_Handler.h \ + $(TAO_ROOT)/tao/Messaging.h \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.i \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + TestC.i TestS_T.h TestS_T.i TestS_T.cpp TestS.i + +.obj/Client_Task.o .obj/Client_Task.o .obj/Client_Task.o .obj/Client_Task.o: Client_Task.cpp Client_Task.h \ + $(ACE_ROOT)/ace/pre.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp + +.obj/AMI_Buffering.o .obj/AMI_Buffering.o .obj/AMI_Buffering.o .obj/AMI_Buffering.o: AMI_Buffering.cpp AMI_Buffering.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(TAO_ROOT)/tao/TimeBaseS.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.h \ + $(TAO_ROOT)/tao/TimeBaseS_T.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ + $(TAO_ROOT)/tao/TimeBaseS.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.i \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Endpoint.i \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.inl \ + $(TAO_ROOT)/tao/Cache_Entries.inl \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.inl \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RT_Policy_i.i \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/Priority_Mapping.i \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Transport.h \ + $(TAO_ROOT)/tao/Transport_Timer.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(TAO_ROOT)/tao/Transport.inl \ + $(TAO_ROOT)/tao/Asynch_Timeout_Handler.h \ + $(TAO_ROOT)/tao/Messaging.h \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.i \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + TestC.i TestS_T.h TestS_T.i TestS_T.cpp TestS.i + +.obj/AMI_Buffering_Admin.o .obj/AMI_Buffering_Admin.o .obj/AMI_Buffering_Admin.o .obj/AMI_Buffering_Admin.o: AMI_Buffering_Admin.cpp AMI_Buffering_Admin.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(TAO_ROOT)/tao/TimeBaseS.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.h \ + $(TAO_ROOT)/tao/TimeBaseS_T.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ + $(TAO_ROOT)/tao/TimeBaseS.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.i \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Endpoint.i \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.inl \ + $(TAO_ROOT)/tao/Cache_Entries.inl \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.inl \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RT_Policy_i.i \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/Priority_Mapping.i \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Transport.h \ + $(TAO_ROOT)/tao/Transport_Timer.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(TAO_ROOT)/tao/Transport.inl \ + $(TAO_ROOT)/tao/Asynch_Timeout_Handler.h \ + $(TAO_ROOT)/tao/Messaging.h \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.i \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + TestC.i TestS_T.h TestS_T.i TestS_T.cpp TestS.i + +.obj/TestC.o .obj/TestC.o .obj/TestC.o .obj/TestC.o: TestC.cpp TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + $(TAO_ROOT)/tao/Messaging.h \ + $(TAO_ROOT)/tao/Asynch_Invocation.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Endpoint.i \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.inl \ + $(TAO_ROOT)/tao/Cache_Entries.inl \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.inl \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBAC.i \ + $(TAO_ROOT)/tao/RT_Policy_i.i \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/Priority_Mapping.i \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Transport.h \ + $(TAO_ROOT)/tao/Transport_Timer.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(TAO_ROOT)/tao/Transport.inl \ + $(TAO_ROOT)/tao/Asynch_Timeout_Handler.h \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.i \ + TestC.i \ + $(TAO_ROOT)/tao/ClientRequestInfo.h \ + $(TAO_ROOT)/tao/ClientRequestInfo.inl \ + $(TAO_ROOT)/tao/RequestInfo_Util.h + +.obj/TestS.o .obj/TestS.o .obj/TestS.o .obj/TestS.o: TestS.cpp TestS.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.h \ + $(ACE_ROOT)/ace/pre.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(TAO_ROOT)/tao/TimeBaseS.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(ACE_ROOT)/ace/CDR_Stream.i \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.inl \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.inl \ + $(TAO_ROOT)/tao/TimeBaseC.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.h \ + $(TAO_ROOT)/tao/TimeBaseS_T.i \ + $(TAO_ROOT)/tao/TimeBaseS_T.cpp \ + $(TAO_ROOT)/tao/TimeBaseS.i \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueBase.i \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/ValueFactory.i \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Managed_Types.i \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/IOPC.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/PollableC.i \ + $(TAO_ROOT)/tao/MessagingC.i \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.i \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/RTCORBAC.i \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.i \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.i \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.i \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.h \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.i \ + $(TAO_ROOT)/tao/PortableServer/MessagingS_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/MessagingS.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.h \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Pluggable.i \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.i \ + $(TAO_ROOT)/tao/Tagged_Components.i \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.i \ + $(TAO_ROOT)/tao/Profile.i \ + $(TAO_ROOT)/tao/MProfile.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/Services.i \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/CORBA_String.inl \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/LocalObject.i \ + $(TAO_ROOT)/tao/Policy_Manager.i \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Adapter.i \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/DynamicC.i \ + $(TAO_ROOT)/tao/PortableInterceptorC.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.i \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.i \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Service_Callbacks.i \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.i \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor.i \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Endpoint.i \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.inl \ + $(TAO_ROOT)/tao/Cache_Entries.inl \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.inl \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.inl \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/Interceptor_List.inl \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RT_Policy_i.i \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/Priority_Mapping.i \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.i \ + $(TAO_ROOT)/tao/TAOC.i \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/Service_Context.inl \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/target_specification.i \ + $(TAO_ROOT)/tao/operation_details.i \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.i \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Transport.h \ + $(TAO_ROOT)/tao/Transport_Timer.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Process_Mutex.inl \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(TAO_ROOT)/tao/Transport.inl \ + $(TAO_ROOT)/tao/Asynch_Timeout_Handler.h \ + $(TAO_ROOT)/tao/Messaging.h \ + $(TAO_ROOT)/tao/Asynch_Reply_Dispatcher.i \ + $(TAO_ROOT)/tao/Asynch_Invocation.i \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/OctetSeqC.i \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/BoundsC.i \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/DomainC.i \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/ObjectIDList.i \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptor.i \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/StringSeqC.i \ + TestC.i TestS_T.h TestS_T.i TestS_T.cpp TestS.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.h \ + $(ACE_ROOT)/ace/Map.h \ + $(ACE_ROOT)/ace/Map_T.h \ + $(ACE_ROOT)/ace/Pair.h \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Active_Map_Manager.h \ + $(ACE_ROOT)/ace/Active_Map_Manager.i \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Map_T.i \ + $(ACE_ROOT)/ace/Map_T.cpp \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.i \ + $(TAO_ROOT)/tao/PortableServer/poa_macros.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.i \ + $(TAO_ROOT)/tao/PortableServer/Operation_Table.h \ + $(TAO_ROOT)/tao/TAO_Server_Request.h \ + $(TAO_ROOT)/tao/Tagged_Profile.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/GIOPC.i \ + $(TAO_ROOT)/tao/Tagged_Profile.i \ + $(TAO_ROOT)/tao/TAO_Server_Request.i \ + $(TAO_ROOT)/tao/IFR_Client_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.inl \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service_Base.h \ + $(ACE_ROOT)/ace/Dynamic_Service.i \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/tests/AMI_Buffering/Makefile.bor b/TAO/tests/AMI_Buffering/Makefile.bor new file mode 100644 index 00000000000..ebf90391f43 --- /dev/null +++ b/TAO/tests/AMI_Buffering/Makefile.bor @@ -0,0 +1,7 @@ +# +# $Id$ +# + +MAKEFILES = admin.bor server.bor client.bor + +!include <$(ACE_ROOT)\include\makeinclude\recurse.bor> diff --git a/TAO/tests/AMI_Buffering/README b/TAO/tests/AMI_Buffering/README new file mode 100644 index 00000000000..7ab74c58127 --- /dev/null +++ b/TAO/tests/AMI_Buffering/README @@ -0,0 +1,32 @@ +/** + +@page AMI_Buffering Test README File + + A regression test for AMI buffering. The test verifies +that the TAO::BufferingConstraint policies are respected by the +ORB. Three separate tests are possible: + +- TAO::BUFFER_MESSAGE_COUNT: The buffer should not be flushed until + enough messages are in the queue. + +- TAO::BUFFER_TIMEOUT: The buffer should not be flushed unless the + specified interval has expired. + +- TAO::BUFFER_MESSAGE_BYTES: The buffer should not be flushed until + enough bytes are in the queue. + + To run the test use run_test.pl script: + +$ ./run_test.pl + + the nightly regression builds impose severe constraints on the +maximum time allowed for a single test. Three separate scripts are +used to stay within those bounds: + +$ ./run_message_count.pl +$ ./run_timeout.pl +$ ./run_message_bytes.pl + + each script returns 0 if the test was successful. + +*/ diff --git a/TAO/tests/AMI_Buffering/Reply_Handler.cpp b/TAO/tests/AMI_Buffering/Reply_Handler.cpp new file mode 100644 index 00000000000..e82471f58be --- /dev/null +++ b/TAO/tests/AMI_Buffering/Reply_Handler.cpp @@ -0,0 +1,82 @@ +// +// $Id$ +// +#include "Reply_Handler.h" + +ACE_RCSID(AMI_Buffering, Reply_Handler, "$Id$") + +Reply_Handler::Reply_Handler (void) +{ +} + +void +Reply_Handler::receive_data (CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +Reply_Handler::receive_data_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_TRY + { + holder->raise_receive_data (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "receive_data: "); + } + ACE_ENDTRY; +} + +void +Reply_Handler::sync (CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +Reply_Handler::sync_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_TRY + { + holder->raise_sync (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "sync: "); + } + ACE_ENDTRY; +} + +void +Reply_Handler::shutdown (CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +Reply_Handler::shutdown_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_TRY + { + holder->raise_shutdown (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "shutdown: "); + } + ACE_ENDTRY; +} diff --git a/TAO/tests/AMI_Buffering/Reply_Handler.h b/TAO/tests/AMI_Buffering/Reply_Handler.h new file mode 100644 index 00000000000..ee0d2665340 --- /dev/null +++ b/TAO/tests/AMI_Buffering/Reply_Handler.h @@ -0,0 +1,52 @@ +// +// $Id$ +// + +#ifndef REPLY_HANDLER_H +#define REPLY_HANDLER_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the AMI_AMI_BufferingHandler interface +class Reply_Handler + : public virtual POA_Test::AMI_AMI_BufferingHandler + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Reply_Handler (void); + + // = The skeleton methods + virtual void receive_data (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual void receive_data_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void sync (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual void sync_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual void shutdown_excep (Test::AMI_AMI_BufferingExceptionHolder *holder, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* REPLY_HANDLER_H */ diff --git a/TAO/tests/AMI_Buffering/Test.idl b/TAO/tests/AMI_Buffering/Test.idl new file mode 100644 index 00000000000..5c757ea0a1b --- /dev/null +++ b/TAO/tests/AMI_Buffering/Test.idl @@ -0,0 +1,55 @@ +// +// $Id$ +// + +/// Put the interfaces in a module, to avoid global namespace pollution +module Test +{ + /// A sequence of octets to generate bigger messages + typedef sequence<octet> Payload; + + /// Clients use this interface to send oneway requests + interface AMI_Buffering + { + /// A simple operation to test the number of requests received. + void receive_data (in Payload the_payload); + + /// An empty operation to force a flush in the ORB queues + oneway void flush (); + + /// Synchronize the state with the Admin object. + /** + * Once flush() has been invoked (with the correct buffering + * policies) we must use sync() to ensure that both the main + * server and the Admin servers are in sync. + */ + void sync (); + + /// Shutdown the server + void shutdown (); + }; + + /// Clients use this interface to query the number of oneway + /// requests received. + interface AMI_Buffering_Admin + { + /// Number of oneway requests received + unsigned long request_count (); + + /// Number of bytes received + unsigned long bytes_received_count (); + + /// The Oneway_Buffering interface uses this method to report any + /// request received. + void request_received (in unsigned long payload_length); + + /// An empty operation to force a flush in the ORB queues + void flush (); + + /// A method to shutdown the ORB + /** + * This method is used to simplify the test shutdown process + */ + void shutdown (); + }; +}; diff --git a/TAO/tests/AMI_Buffering/admin.bor b/TAO/tests/AMI_Buffering/admin.bor new file mode 100644 index 00000000000..220a5c6cf5f --- /dev/null +++ b/TAO/tests/AMI_Buffering/admin.bor @@ -0,0 +1,39 @@ +# +# $Id$ +# + +NAME = admin + +TAO_IDL = $(CORE_BINDIR)\tao_idl -g $(CORE_BINDIR)\gperf.exe -Ge 1 + +OBJFILES = \ + $(OBJDIR)\TestC.obj \ + $(OBJDIR)\TestS.obj \ + $(OBJDIR)\AMI_Buffering_Admin.obj \ + $(OBJDIR)\admin.obj + +CFLAGS = \ + $(ACE_CFLAGS) \ + $(TAO_CFLAGS) \ + $(TAO_PORTABLESERVER_CFLAGS) + +LIBFILES = \ + $(ACE_LIB) \ + $(TAO_LIB) \ + $(TAO_PORTABLESERVER_LIB) + +IDLFILES = \ + $(IDLDIR)\Test.idl + +CPPDIR = . + +IDLDIR = . + +!include <$(ACE_ROOT)\include\makeinclude\build_exe.bor> + +# +# IDL Build rules +# + +$(IDLDIR)\TestS.cpp $(IDLDIR)\TestC.cpp: $(IDLDIR)\Test.idl + $(TAO_IDL) $** diff --git a/TAO/tests/AMI_Buffering/admin.cpp b/TAO/tests/AMI_Buffering/admin.cpp new file mode 100644 index 00000000000..8f6e82d3b48 --- /dev/null +++ b/TAO/tests/AMI_Buffering/admin.cpp @@ -0,0 +1,112 @@ +// $Id$ + +#include "AMI_Buffering_Admin.h" +#include "ace/Get_Opt.h" + +ACE_RCSID(AMI_Buffering, admin, "$Id$") + +const char *ior_output_file = "admin.ior"; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "o:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + ior_output_file = get_opts.optarg; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-o <iorfile>" + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + ACE_TRY_CHECK; + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (root_poa.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Panic: nil RootPOA\n"), + 1); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + AMI_Buffering_Admin *AMI_buffering_admin_impl; + ACE_NEW_RETURN (AMI_buffering_admin_impl, + AMI_Buffering_Admin (orb.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(AMI_buffering_admin_impl); + + Test::AMI_Buffering_Admin_var AMI_buffering_admin = + AMI_buffering_admin_impl->_this (ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (AMI_buffering_admin.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + // If the ior_output_file exists, output the ior to it + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + + poa_manager->activate (ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->run (ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) admin - event loop finished\n")); + + root_poa->destroy (1, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/AMI_Buffering/admin.dsp b/TAO/tests/AMI_Buffering/admin.dsp new file mode 100644 index 00000000000..79b260204f2 --- /dev/null +++ b/TAO/tests/AMI_Buffering/admin.dsp @@ -0,0 +1,216 @@ +# Microsoft Developer Studio Project File - Name="AMI_Buffering Admin" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=AMI_Buffering Admin - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "admin.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "admin.mak" CFG="AMI_Buffering Admin - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "AMI_Buffering Admin - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "AMI_Buffering Admin - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "AMI_Buffering Admin - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../../" /I "../../" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 TAO.lib TAO_PortableServer.lib ace.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ELSEIF "$(CFG)" == "AMI_Buffering Admin - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "../../../" /I "../../" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 TAOd.lib TAO_PortableServerd.lib aced.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ENDIF
+
+# Begin Target
+
+# Name "AMI_Buffering Admin - Win32 Release"
+# Name "AMI_Buffering Admin - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\admin.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\AMI_Buffering_Admin.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ".h"
+# Begin Source File
+
+SOURCE=.\AMI_Buffering_Admin.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\Test.idl
+
+!IF "$(CFG)" == "AMI_Buffering Admin - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "AMI_Buffering Admin - Win32 Debug"
+
+USERDEP__TEST_="..\..\..\bin\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\tao_idl -Ge 1 -GC $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Inline Files"
+
+# PROP Default_Filter ".i"
+# Begin Source File
+
+SOURCE=.\TestC.i
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.i
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/tests/AMI_Buffering/client.bor b/TAO/tests/AMI_Buffering/client.bor new file mode 100644 index 00000000000..f293a62e0bd --- /dev/null +++ b/TAO/tests/AMI_Buffering/client.bor @@ -0,0 +1,39 @@ +# +# $Id$ +# + +NAME = client + +TAO_IDL = $(CORE_BINDIR)\tao_idl -g $(CORE_BINDIR)\gperf.exe -Ge 1 + +OBJFILES = \ + $(OBJDIR)\TestC.obj \ + $(OBJDIR)\TestS.obj \ + $(OBJDIR)\Reply_Handler.obj \ + $(OBJDIR)\server.obj + +CFLAGS = \ + $(ACE_CFLAGS) \ + $(TAO_CFLAGS) \ + $(TAO_PORTABLESERVER_CFLAGS) + +LIBFILES = \ + $(ACE_LIB) \ + $(TAO_LIB) \ + $(TAO_PORTABLESERVER_LIB) + +IDLFILES = \ + $(IDLDIR)\Test.idl + +CPPDIR = . + +IDLDIR = . + +!include <$(ACE_ROOT)\include\makeinclude\build_exe.bor> + +# +# IDL Build rules +# + +$(IDLDIR)\TestS.cpp $(IDLDIR)\TestC.cpp: $(IDLDIR)\Test.idl + $(TAO_IDL) $** diff --git a/TAO/tests/AMI_Buffering/client.cpp b/TAO/tests/AMI_Buffering/client.cpp new file mode 100644 index 00000000000..04238d4d082 --- /dev/null +++ b/TAO/tests/AMI_Buffering/client.cpp @@ -0,0 +1,863 @@ +// $Id$ + +#include "Reply_Handler.h" +#include "Client_Task.h" +#include "tao/Messaging.h" +#include "tao/TAOC.h" +#include "ace/Get_Opt.h" + +ACE_RCSID(AMI_Buffering, client, "$Id$") + +const char *server_ior = "file://server.ior"; +const char *admin_ior = "file://admin.ior"; +int iterations = 200; + +int run_message_count_test = 0; +int run_timeout_test = 0; +int run_timeout_reactive_test = 0; +int run_buffer_size_test = 0; + +const int PAYLOAD_LENGTH = 1024; +const int BUFFERED_MESSAGES_COUNT = 50; +const int TIMEOUT_MILLISECONDS = 50; +const int BUFFER_SIZE = 64 * PAYLOAD_LENGTH; + +/// Check that no more than 10% of the messages are not sent. +const double LIVENESS_TOLERANCE = 0.9; + +/// Factor in GIOP overhead in the buffer size test +const double GIOP_OVERHEAD = 0.9; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "k:a:i:ctbr"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'k': + server_ior = get_opts.optarg; + break; + + case 'a': + admin_ior = get_opts.optarg; + break; + + case 'i': + iterations = ACE_OS::atoi (get_opts.optarg); + break; + + case 'c': + run_message_count_test = 1; + break; + + case 't': + run_timeout_test = 1; + break; + + case 'b': + run_buffer_size_test = 1; + break; + + case 'r': + run_timeout_reactive_test = 1; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <server_ior> " + "-a <admin_ior> " + "-i <iterations> " + "<-c|-t|-b|-r> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +run_message_count (CORBA::ORB_ptr orb, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_Admin_ptr ami_buffering_admin, + CORBA::Environment &ACE_TRY_ENV); +int +run_timeout (CORBA::ORB_ptr orb, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_Admin_ptr ami_buffering_admin, + CORBA::Environment &ACE_TRY_ENV); + +int +run_timeout_reactive (CORBA::ORB_ptr orb, + Test::AMI_Buffering_ptr oneway_buffering, + Test::AMI_Buffering_Admin_ptr oneway_buffering_admin, + CORBA::Environment &ACE_TRY_ENV); + +int +run_buffer_size (CORBA::ORB_ptr orb, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_Admin_ptr ami_buffering_admin, + CORBA::Environment &ACE_TRY_ENV); + +int +main (int argc, char *argv[]) +{ + int test_failed = 0; + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + ACE_TRY_CHECK; + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (root_poa.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Panic: nil RootPOA\n"), + 1); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_TRY_ENV); + ACE_TRY_CHECK; + + poa_manager->activate (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var tmp = + orb->string_to_object(server_ior, ACE_TRY_ENV); + ACE_TRY_CHECK; + + Test::AMI_Buffering_var ami_buffering = + Test::AMI_Buffering::_narrow(tmp.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (ami_buffering.in ())) + { + ACE_ERROR_RETURN ((LM_DEBUG, + "Nil Test::AMI_Buffering reference <%s>\n", + server_ior), + 1); + } + + tmp = + orb->string_to_object(admin_ior, ACE_TRY_ENV); + ACE_TRY_CHECK; + + Test::AMI_Buffering_Admin_var ami_buffering_admin = + Test::AMI_Buffering_Admin::_narrow(tmp.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (ami_buffering_admin.in ())) + { + ACE_ERROR_RETURN ((LM_DEBUG, + "Nil Test::AMI_Buffering_Admin reference <%s>\n", + admin_ior), + 1); + } + + Client_Task client_task (orb.in ()); + if (client_task.activate (THR_NEW_LWP | THR_JOINABLE) == -1) + { + ACE_ERROR ((LM_ERROR, "Error activating client task\n")); + } + + if (run_message_count_test) + { + ACE_DEBUG ((LM_DEBUG, + "Running message count flushing test\n")); + test_failed = + run_message_count (orb.in (), + ami_buffering.in (), + ami_buffering_admin.in (), + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + else if (run_timeout_test) + { + ACE_DEBUG ((LM_DEBUG, + "Running timeout flushing test\n")); + test_failed = + run_timeout (orb.in (), + ami_buffering.in (), + ami_buffering_admin.in (), + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + else if (run_timeout_reactive_test) + { + ACE_DEBUG ((LM_DEBUG, + "Running timeout (reactive) flushing test\n")); + test_failed = + run_timeout_reactive (orb.in (), + ami_buffering.in (), + ami_buffering_admin.in (), + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + else if (run_buffer_size_test) + { + ACE_DEBUG ((LM_DEBUG, + "Running buffer size flushing test\n")); + test_failed = + run_buffer_size (orb.in (), + ami_buffering.in (), + ami_buffering_admin.in (), + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + else + { + ACE_ERROR ((LM_ERROR, + "ERROR: No test was configured\n")); + } + + client_task.terminate_loop (); + + client_task.thr_mgr ()->wait (); + + ami_buffering->shutdown (ACE_TRY_ENV); + ACE_TRY_CHECK; + + ami_buffering_admin->shutdown (ACE_TRY_ENV); + ACE_TRY_CHECK; + + root_poa->destroy (1, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return test_failed; +} + +int +configure_policies (CORBA::ORB_ptr orb, + const TAO::BufferingConstraint &buffering_constraint, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_out flusher, + CORBA::Environment &ACE_TRY_ENV) +{ + CORBA::Object_var object = + orb->resolve_initial_references ("PolicyCurrent", ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::PolicyCurrent_var policy_current = + CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (CORBA::is_nil (policy_current.in ())) + { + ACE_ERROR ((LM_ERROR, "ERROR: Nil policy current\n")); + return 1; + } + CORBA::Any scope_as_any; + scope_as_any <<= Messaging::SYNC_NONE; + + CORBA::Any buffering_as_any; + buffering_as_any <<= buffering_constraint; + + CORBA::PolicyList policies (2); policies.length (2); + policies[0] = + orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, + scope_as_any, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + policies[1] = + orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, + buffering_as_any, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + policy_current->set_policy_overrides (policies, CORBA::ADD_OVERRIDE, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + policies[0]->destroy (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + policies[1]->destroy (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + TAO::BufferingConstraint flush_constraint; + flush_constraint.mode = TAO::BUFFER_FLUSH; + flush_constraint.message_count = 0; + flush_constraint.message_bytes = 0; + flush_constraint.timeout = 0; + + buffering_as_any <<= flush_constraint; + policies.length (1); + policies[0] = + orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, + buffering_as_any, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + object = + ami_buffering->_set_policy_overrides (policies, + CORBA::ADD_OVERRIDE, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + policies[0]->destroy (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + flusher = + Test::AMI_Buffering::_narrow (object.in (), ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + return 0; +} + +int +run_liveness_test (Test::AMI_AMI_BufferingHandler_ptr reply_handler, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_ptr flusher, + Test::AMI_Buffering_Admin_ptr ami_buffering_admin, + CORBA::Environment &ACE_TRY_ENV) +{ + ACE_DEBUG ((LM_DEBUG, ".... checking for liveness\n")); + int test_failed = 0; + + // Get back in sync with the server... + flusher->flush (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + flusher->sync (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong send_count = + ami_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + int liveness_test_iterations = int(send_count); + + Test::Payload payload (PAYLOAD_LENGTH); + payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); + + for (int i = 0; i != liveness_test_iterations; ++i) + { + ami_buffering->sendc_receive_data (reply_handler, + payload, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + send_count++; + + CORBA::ULong receive_count = + ami_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + // Once the system has sent enough messages we don't + // expect it to fall too far behind, i.e. at least 90% of the + // messages should be delivered.... + CORBA::ULong expected = + CORBA::ULong (LIVENESS_TOLERANCE * send_count); + + if (receive_count < expected) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d " + "not enough messages received %u " + "expected %u\n", + i, receive_count, expected)); + } + } + + return test_failed; +} + +int +run_message_count (CORBA::ORB_ptr orb, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_Admin_ptr ami_buffering_admin, + CORBA::Environment &ACE_TRY_ENV) +{ + TAO::BufferingConstraint buffering_constraint; + buffering_constraint.mode = TAO::BUFFER_MESSAGE_COUNT; + buffering_constraint.message_count = BUFFERED_MESSAGES_COUNT; + buffering_constraint.message_bytes = 0; + buffering_constraint.timeout = 0; + + Test::AMI_Buffering_var flusher; + int test_failed = + configure_policies (orb, buffering_constraint, + ami_buffering, flusher.out (), + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (test_failed != 0) + return test_failed; + + Test::Payload payload (PAYLOAD_LENGTH); + payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); + + Reply_Handler *reply_handler_impl; + ACE_NEW_RETURN (reply_handler_impl, + Reply_Handler, + 1); + PortableServer::ServantBase_var owner_transfer(reply_handler_impl); + + Test::AMI_AMI_BufferingHandler_var reply_handler = + reply_handler_impl->_this (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong send_count = 0; + for (int i = 0; i != iterations; ++i) + { + // Get back in sync with the server... + flusher->flush (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + flusher->sync (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong initial_receive_count = + ami_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (initial_receive_count != send_count) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d message lost (%u != %u)\n", + i, initial_receive_count, send_count)); + } + + while (1) + { + ami_buffering->sendc_receive_data (reply_handler.in (), + payload, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + send_count++; + + CORBA::ULong receive_count = + ami_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong iteration_count = + send_count - initial_receive_count; + if (receive_count != initial_receive_count) + { + if (iteration_count < CORBA::ULong(BUFFERED_MESSAGES_COUNT)) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d flush before " + "message count reached. " + "Iteration count = %u, Threshold = %u\n", + i, + iteration_count, BUFFERED_MESSAGES_COUNT)); + } + break; + } + + if (iteration_count > 2 * BUFFERED_MESSAGES_COUNT) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d no flush past " + "message count threshold. " + "Iteration count = %u, Threshold = %u\n", + i, + iteration_count, BUFFERED_MESSAGES_COUNT)); + break; + } + } + } + + int liveness_test_failed = + run_liveness_test (reply_handler.in (), + ami_buffering, + flusher.in (), + ami_buffering_admin, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (liveness_test_failed) + test_failed = 1; + + return test_failed; +} + +int +run_timeout (CORBA::ORB_ptr orb, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_Admin_ptr ami_buffering_admin, + CORBA::Environment &ACE_TRY_ENV) +{ + TAO::BufferingConstraint buffering_constraint; + buffering_constraint.mode = TAO::BUFFER_TIMEOUT; + buffering_constraint.message_count = 0; + buffering_constraint.message_bytes = 0; + buffering_constraint.timeout = TIMEOUT_MILLISECONDS * 10000; + + Test::AMI_Buffering_var flusher; + int test_failed = + configure_policies (orb, buffering_constraint, + ami_buffering, flusher.out (), + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (test_failed != 0) + return test_failed; + + Test::Payload payload (PAYLOAD_LENGTH); + payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); + + Reply_Handler *reply_handler_impl; + ACE_NEW_RETURN (reply_handler_impl, + Reply_Handler, + 1); + PortableServer::ServantBase_var owner_transfer(reply_handler_impl); + + Test::AMI_AMI_BufferingHandler_var reply_handler = + reply_handler_impl->_this (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong send_count = 0; + for (int i = 0; i != iterations; ++i) + { + // Get back in sync with the server... + flusher->flush (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + flusher->sync (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong initial_receive_count = + ami_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (initial_receive_count != send_count) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d message lost (%u != %u)\n", + i, initial_receive_count, send_count)); + } + + ACE_Time_Value start = ACE_OS::gettimeofday (); + while (1) + { + ami_buffering->sendc_receive_data (reply_handler.in (), + payload, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + send_count++; + + CORBA::ULong receive_count = + ami_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + ACE_Time_Value elapsed = ACE_OS::gettimeofday () - start; + if (receive_count != initial_receive_count) + { + if (elapsed.msec () < TIMEOUT_MILLISECONDS) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d flush before " + "timeout expired. " + "Elapsed = %d, Timeout = %d msecs\n", + i, + elapsed.msec (), TIMEOUT_MILLISECONDS)); + } + // terminate the while loop. + break; + } + + if (elapsed.msec () > 2 * TIMEOUT_MILLISECONDS) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d no flush past " + "timeout threshold. " + "Elapsed = %d, Timeout = %d msecs\n", + i, + elapsed.msec (), TIMEOUT_MILLISECONDS)); + break; + } + } + } + + int liveness_test_failed = + run_liveness_test (reply_handler.in (), + ami_buffering, + flusher.in (), + ami_buffering_admin, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (liveness_test_failed) + test_failed = 1; + + return test_failed; +} + +int +run_timeout_reactive (CORBA::ORB_ptr orb, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_Admin_ptr ami_buffering_admin, + CORBA::Environment &ACE_TRY_ENV) +{ + TAO::BufferingConstraint buffering_constraint; + buffering_constraint.mode = TAO::BUFFER_TIMEOUT; + buffering_constraint.message_count = 0; + buffering_constraint.message_bytes = 0; + buffering_constraint.timeout = TIMEOUT_MILLISECONDS * 10000; + + Test::AMI_Buffering_var flusher; + int test_failed = + configure_policies (orb, buffering_constraint, + ami_buffering, flusher.out (), + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (test_failed != 0) + return test_failed; + + Test::Payload payload (PAYLOAD_LENGTH); + payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); + + Reply_Handler *reply_handler_impl; + ACE_NEW_RETURN (reply_handler_impl, + Reply_Handler, + 1); + PortableServer::ServantBase_var owner_transfer(reply_handler_impl); + + Test::AMI_AMI_BufferingHandler_var reply_handler = + reply_handler_impl->_this (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong send_count = 0; + for (int i = 0; i != iterations; ++i) + { + // Get back in sync with the server... + flusher->flush (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + flusher->sync (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong initial_receive_count = + ami_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (initial_receive_count != send_count) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d message lost (%u != %u)\n", + i, initial_receive_count, send_count)); + } + + ACE_Time_Value start = ACE_OS::gettimeofday (); + for (int j = 0; j != 20; ++j) + { + ami_buffering->sendc_receive_data (reply_handler.in (), + payload, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + send_count++; + } + while (1) + { + CORBA::ULong receive_count = + ami_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + ACE_Time_Value sleep (0, 10000); + orb->run (sleep, ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + ACE_Time_Value elapsed = ACE_OS::gettimeofday () - start; + if (receive_count != initial_receive_count) + { + if (elapsed.msec () < TIMEOUT_MILLISECONDS) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d flush before " + "timeout expired. " + "Elapsed = %d, Timeout = %d msecs\n", + i, + elapsed.msec (), TIMEOUT_MILLISECONDS)); + } + // terminate the while loop. + break; + } + + if (elapsed.msec () > 2 * TIMEOUT_MILLISECONDS) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d no flush past " + "timeout threshold. " + "Elapsed = %d, Timeout = %d msecs\n", + i, + elapsed.msec (), TIMEOUT_MILLISECONDS)); + break; + } + } + } + +#if 0 + int liveness_test_failed = + run_liveness_test (reply_handler.in (), + ami_buffering, + flusher.in (), + ami_buffering_admin, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (liveness_test_failed) + test_failed = 1; +#endif /* 0 */ + + + return test_failed; +} + +int +run_buffer_size (CORBA::ORB_ptr orb, + Test::AMI_Buffering_ptr ami_buffering, + Test::AMI_Buffering_Admin_ptr ami_buffering_admin, + CORBA::Environment &ACE_TRY_ENV) +{ + TAO::BufferingConstraint buffering_constraint; + buffering_constraint.mode = TAO::BUFFER_MESSAGE_BYTES; + buffering_constraint.message_count = 0; + buffering_constraint.message_bytes = BUFFER_SIZE; + buffering_constraint.timeout = 0; + + Test::AMI_Buffering_var flusher; + int test_failed = + configure_policies (orb, buffering_constraint, + ami_buffering, flusher.out (), + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (test_failed != 0) + return test_failed; + + Test::Payload payload (PAYLOAD_LENGTH); + payload.length (PAYLOAD_LENGTH); + + Reply_Handler *reply_handler_impl; + ACE_NEW_RETURN (reply_handler_impl, + Reply_Handler, + 1); + PortableServer::ServantBase_var owner_transfer(reply_handler_impl); + + Test::AMI_AMI_BufferingHandler_var reply_handler = + reply_handler_impl->_this (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong bytes_sent = 0; + for (int i = 0; i != iterations; ++i) + { + // Get back in sync with the server... + flusher->flush (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + flusher->sync (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong initial_bytes_received = + ami_buffering_admin->bytes_received_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (initial_bytes_received != bytes_sent) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d data lost (%u != %u)\n", + i, initial_bytes_received, bytes_sent)); + } + + while (1) + { + ami_buffering->sendc_receive_data (reply_handler.in (), + payload, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + bytes_sent += PAYLOAD_LENGTH; + + CORBA::ULong bytes_received = + ami_buffering_admin->bytes_received_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong payload_delta = + bytes_sent - initial_bytes_received; + if (bytes_received != initial_bytes_received) + { + // The queue has been flushed, check that enough data + // has been sent. The check cannot be precise because + // the ORB counts the GIOP message overhead, in this + // test we assume the overhead to be less than 10% + + if (payload_delta < CORBA::ULong (GIOP_OVERHEAD * BUFFER_SIZE)) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d flush before " + "minimum buffer size was reached. " + "Sent = %u, Minimum buffer = %u bytes\n", + i, + payload_delta, BUFFER_SIZE)); + } + break; + } + + if (payload_delta > 2 * BUFFER_SIZE) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d no flush past " + "buffer size threshold. " + "Sent = %u, Minimum buffer = %u bytes\n", + i, + payload_delta, BUFFER_SIZE)); + break; + } + } + } + + int liveness_test_failed = + run_liveness_test (reply_handler.in (), + ami_buffering, + flusher.in (), + ami_buffering_admin, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (liveness_test_failed) + test_failed = 1; + + return test_failed; +} diff --git a/TAO/tests/AMI_Buffering/client.dsp b/TAO/tests/AMI_Buffering/client.dsp new file mode 100644 index 00000000000..0e90456d554 --- /dev/null +++ b/TAO/tests/AMI_Buffering/client.dsp @@ -0,0 +1,224 @@ +# Microsoft Developer Studio Project File - Name="AMI_Buffering Client" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=AMI_Buffering Client - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak" CFG="AMI_Buffering Client - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "AMI_Buffering Client - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "AMI_Buffering Client - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "AMI_Buffering Client - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../../" /I "../../" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 tao.lib ace.lib TAO.lib TAO_PortableServer.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\ace" /libpath:"..\..\tao" /libpath:"..\..\tao\PortableServer"
+
+!ELSEIF "$(CFG)" == "AMI_Buffering Client - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "../../../" /I "../../" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 taod.lib aced.lib TAOd.lib TAO_PortableServerd.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\ace" /libpath:"..\..\tao" /libpath:"..\..\tao\PortableServer"
+
+!ENDIF
+
+# Begin Target
+
+# Name "AMI_Buffering Client - Win32 Release"
+# Name "AMI_Buffering Client - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Client_Task.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Reply_Handler.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Client_Task.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Reply_Handler.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestC.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Test.idl
+
+!IF "$(CFG)" == "AMI_Buffering Client - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "AMI_Buffering Client - Win32 Debug"
+
+USERDEP__TEST_="..\..\..\bin\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\tao_idl -Ge 1 -GC $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Inline Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\TestC.i
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/tests/AMI_Buffering/run_buffer_size.pl b/TAO/tests/AMI_Buffering/run_buffer_size.pl new file mode 100755 index 00000000000..d753ab02cf4 --- /dev/null +++ b/TAO/tests/AMI_Buffering/run_buffer_size.pl @@ -0,0 +1,65 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; + +$admin_iorfile = PerlACE::LocalFile ("admin.ior"); +$server_iorfile = PerlACE::LocalFile ("server.ior"); + +unlink $admin_iorfile; +unlink $server_iorfile; + +my $AD = new PerlACE::Process ("admin", "-o $admin_iorfile"); +my $SV = new PerlACE::Process ("server", "-o $server_iorfile"); +my $CL = new PerlACE::Process ("client", + " -k file://$server_iorfile " + ."-a file://$admin_iorfile " + ."-b "); + +$AD->Spawn (); + +if (PerlACE::waitforfile_timed ($admin_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$admin_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + exit 1; +} + +$SV->Spawn (); + +if (PerlACE::waitforfile_timed ($server_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$server_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + $SV->Kill (); $SV->TimedWait (1); + exit 1; +} + +$client = $CL->SpawnWaitKill (300); + +if ($client != 0) { + print STDERR "ERROR: client returned $client\n"; + $status = 1; +} + +$server = $SV->WaitKill (10); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; +} + +$admin = $AD->WaitKill (10); + +if ($admin != 0) { + print STDERR "ERROR: admin returned $admin\n"; + $status = 1; +} + +unlink $server_iorfile; +unlink $admin_iorfile; + +exit $status; diff --git a/TAO/tests/AMI_Buffering/run_message_count.pl b/TAO/tests/AMI_Buffering/run_message_count.pl new file mode 100755 index 00000000000..8d8f727425b --- /dev/null +++ b/TAO/tests/AMI_Buffering/run_message_count.pl @@ -0,0 +1,65 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; + +$admin_iorfile = PerlACE::LocalFile ("admin.ior"); +$server_iorfile = PerlACE::LocalFile ("server.ior"); + +unlink $admin_iorfile; +unlink $server_iorfile; + +my $AD = new PerlACE::Process ("admin", "-o $admin_iorfile"); +my $SV = new PerlACE::Process ("server", "-o $server_iorfile"); +my $CL = new PerlACE::Process ("client", + " -k file://$server_iorfile " + ."-a file://$admin_iorfile " + ."-c "); + +$AD->Spawn (); + +if (PerlACE::waitforfile_timed ($admin_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$admin_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + exit 1; +} + +$SV->Spawn (); + +if (PerlACE::waitforfile_timed ($server_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$server_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + $SV->Kill (); $SV->TimedWait (1); + exit 1; +} + +$client = $CL->SpawnWaitKill (300); + +if ($client != 0) { + print STDERR "ERROR: client returned $client\n"; + $status = 1; +} + +$server = $SV->WaitKill (10); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; +} + +$admin = $AD->WaitKill (10); + +if ($admin != 0) { + print STDERR "ERROR: admin returned $admin\n"; + $status = 1; +} + +unlink $server_iorfile; +unlink $admin_iorfile; + +exit $status; diff --git a/TAO/tests/AMI_Buffering/run_test.pl b/TAO/tests/AMI_Buffering/run_test.pl new file mode 100755 index 00000000000..30593090375 --- /dev/null +++ b/TAO/tests/AMI_Buffering/run_test.pl @@ -0,0 +1,67 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; + +$admin_iorfile = PerlACE::LocalFile ("admin.ior"); +$server_iorfile = PerlACE::LocalFile ("server.ior"); + +foreach $test_type ("-c", "-t", "-b") { + unlink $admin_iorfile; + unlink $server_iorfile; + + my $AD = new PerlACE::Process ("admin", "-o $admin_iorfile"); + my $SV = new PerlACE::Process ("server", "-o $server_iorfile"); + my $CL = new PerlACE::Process ("client", + " -k file://$server_iorfile " + ."-a file://$admin_iorfile " + .$test_type); + + $AD->Spawn (); + + if (PerlACE::waitforfile_timed ($admin_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$admin_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + exit 1; + } + + $SV->Spawn (); + + if (PerlACE::waitforfile_timed ($server_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$server_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + $SV->Kill (); $SV->TimedWait (1); + exit 1; + } + + $client = $CL->SpawnWaitKill (300); + + if ($client != 0) { + print STDERR "ERROR: client returned $client\n"; + $status = 1; + } + + $server = $SV->WaitKill (10); + + if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; + } + + $admin = $AD->WaitKill (10); + + if ($admin != 0) { + print STDERR "ERROR: admin returned $admin\n"; + $status = 1; + } +} + +unlink $server_iorfile; +unlink $admin_iorfile; + +exit $status; diff --git a/TAO/tests/AMI_Buffering/run_timeout.pl b/TAO/tests/AMI_Buffering/run_timeout.pl new file mode 100755 index 00000000000..9352c94075d --- /dev/null +++ b/TAO/tests/AMI_Buffering/run_timeout.pl @@ -0,0 +1,65 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; + +$admin_iorfile = PerlACE::LocalFile ("admin.ior"); +$server_iorfile = PerlACE::LocalFile ("server.ior"); + +unlink $admin_iorfile; +unlink $server_iorfile; + +my $AD = new PerlACE::Process ("admin", "-o $admin_iorfile"); +my $SV = new PerlACE::Process ("server", "-o $server_iorfile"); +my $CL = new PerlACE::Process ("client", + " -k file://$server_iorfile " + ."-a file://$admin_iorfile " + ."-t "); + +$AD->Spawn (); + +if (PerlACE::waitforfile_timed ($admin_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$admin_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + exit 1; +} + +$SV->Spawn (); + +if (PerlACE::waitforfile_timed ($server_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$server_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + $SV->Kill (); $SV->TimedWait (1); + exit 1; +} + +$client = $CL->SpawnWaitKill (600); + +if ($client != 0) { + print STDERR "ERROR: client returned $client\n"; + $status = 1; +} + +$server = $SV->WaitKill (10); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; +} + +$admin = $AD->WaitKill (10); + +if ($admin != 0) { + print STDERR "ERROR: admin returned $admin\n"; + $status = 1; +} + +unlink $server_iorfile; +unlink $admin_iorfile; + +exit $status; diff --git a/TAO/tests/AMI_Buffering/run_timeout_reactive.pl b/TAO/tests/AMI_Buffering/run_timeout_reactive.pl new file mode 100755 index 00000000000..31f09190b88 --- /dev/null +++ b/TAO/tests/AMI_Buffering/run_timeout_reactive.pl @@ -0,0 +1,65 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; + +$admin_iorfile = PerlACE::LocalFile ("admin.ior"); +$server_iorfile = PerlACE::LocalFile ("server.ior"); + +unlink $admin_iorfile; +unlink $server_iorfile; + +my $AD = new PerlACE::Process ("admin", "-o $admin_iorfile"); +my $SV = new PerlACE::Process ("server", "-o $server_iorfile"); +my $CL = new PerlACE::Process ("client", + " -k file://$server_iorfile " + ."-a file://$admin_iorfile " + ."-r "); + +$AD->Spawn (); + +if (PerlACE::waitforfile_timed ($admin_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$admin_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + exit 1; +} + +$SV->Spawn (); + +if (PerlACE::waitforfile_timed ($server_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$server_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + $SV->Kill (); $SV->TimedWait (1); + exit 1; +} + +$client = $CL->SpawnWaitKill (300); + +if ($client != 0) { + print STDERR "ERROR: client returned $client\n"; + $status = 1; +} + +$server = $SV->WaitKill (10); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; +} + +$admin = $AD->WaitKill (10); + +if ($admin != 0) { + print STDERR "ERROR: admin returned $admin\n"; + $status = 1; +} + +unlink $server_iorfile; +unlink $admin_iorfile; + +exit $status; diff --git a/TAO/tests/AMI_Buffering/server.bor b/TAO/tests/AMI_Buffering/server.bor new file mode 100644 index 00000000000..cedc8f09556 --- /dev/null +++ b/TAO/tests/AMI_Buffering/server.bor @@ -0,0 +1,39 @@ +# +# $Id$ +# + +NAME = server + +TAO_IDL = $(CORE_BINDIR)\tao_idl -g $(CORE_BINDIR)\gperf.exe -Ge 1 + +OBJFILES = \ + $(OBJDIR)\TestC.obj \ + $(OBJDIR)\TestS.obj \ + $(OBJDIR)\AMI_Buffering.obj \ + $(OBJDIR)\server.obj + +CFLAGS = \ + $(ACE_CFLAGS) \ + $(TAO_CFLAGS) \ + $(TAO_PORTABLESERVER_CFLAGS) + +LIBFILES = \ + $(ACE_LIB) \ + $(TAO_LIB) \ + $(TAO_PORTABLESERVER_LIB) + +IDLFILES = \ + $(IDLDIR)\Test.idl + +CPPDIR = . + +IDLDIR = . + +!include <$(ACE_ROOT)\include\makeinclude\build_exe.bor> + +# +# IDL Build rules +# + +$(IDLDIR)\TestS.cpp $(IDLDIR)\TestC.cpp: $(IDLDIR)\Test.idl + $(TAO_IDL) $** diff --git a/TAO/tests/AMI_Buffering/server.cpp b/TAO/tests/AMI_Buffering/server.cpp new file mode 100644 index 00000000000..17d74cb83b5 --- /dev/null +++ b/TAO/tests/AMI_Buffering/server.cpp @@ -0,0 +1,135 @@ +// $Id$ + +#include "AMI_Buffering.h" +#include "ace/Get_Opt.h" + +ACE_RCSID(AMI_Buffering, server, "$Id$") + +const char *ior_output_file = "server.ior"; +const char *ior = "file://admin.ior"; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "o:k:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + ior_output_file = get_opts.optarg; + break; + + case 'k': + ior = get_opts.optarg; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-o <iorfile> " + "-k <ior> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + ACE_TRY_CHECK; + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (root_poa.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Panic: nil RootPOA\n"), + 1); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var tmp = + orb->string_to_object(ior, ACE_TRY_ENV); + ACE_TRY_CHECK; + + Test::AMI_Buffering_Admin_var admin = + Test::AMI_Buffering_Admin::_narrow(tmp.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (admin.in ())) + { + ACE_ERROR_RETURN ((LM_DEBUG, + "Nil AMI_Buffering_Admin reference <%s>\n", + ior), + 1); + } + + AMI_Buffering *AMI_buffering_impl; + ACE_NEW_RETURN (AMI_buffering_impl, + AMI_Buffering (orb.in (), + admin.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(AMI_buffering_impl); + + Test::AMI_Buffering_var AMI_buffering = + AMI_buffering_impl->_this (ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (AMI_buffering.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + // If the ior_output_file exists, output the ior to it + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + + poa_manager->activate (ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->run (ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + root_poa->destroy (1, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/AMI_Buffering/server.dsp b/TAO/tests/AMI_Buffering/server.dsp new file mode 100644 index 00000000000..65278067a7a --- /dev/null +++ b/TAO/tests/AMI_Buffering/server.dsp @@ -0,0 +1,216 @@ +# Microsoft Developer Studio Project File - Name="AMI_Buffering Server" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=AMI_Buffering Server - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak" CFG="AMI_Buffering Server - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "AMI_Buffering Server - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "AMI_Buffering Server - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "AMI_Buffering Server - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../../" /I "../../" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 TAO.lib TAO_PortableServer.lib ace.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ELSEIF "$(CFG)" == "AMI_Buffering Server - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "../../../" /I "../../" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 TAOd.lib TAO_PortableServerd.lib aced.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ENDIF
+
+# Begin Target
+
+# Name "AMI_Buffering Server - Win32 Release"
+# Name "AMI_Buffering Server - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\AMI_Buffering.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ".h"
+# Begin Source File
+
+SOURCE=.\AMI_Buffering.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\Test.idl
+
+!IF "$(CFG)" == "AMI_Buffering Server - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "AMI_Buffering Server - Win32 Debug"
+
+USERDEP__TEST_="..\..\..\bin\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\tao_idl -Ge 1 -GC $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Inline Files"
+
+# PROP Default_Filter ".i"
+# Begin Source File
+
+SOURCE=.\TestC.i
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.i
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/tests/AMI_Buffering/svc.conf b/TAO/tests/AMI_Buffering/svc.conf new file mode 100644 index 00000000000..9fb75aeb0dd --- /dev/null +++ b/TAO/tests/AMI_Buffering/svc.conf @@ -0,0 +1,4 @@ +# +# $Id$ +# +static Client_Strategy_Factory "-ORBTransportMuxStrategy MUXED" diff --git a/TAO/tests/Big_Oneways/Big_Oneways.dsw b/TAO/tests/Big_Oneways/Big_Oneways.dsw new file mode 100644 index 00000000000..33c4973b960 --- /dev/null +++ b/TAO/tests/Big_Oneways/Big_Oneways.dsw @@ -0,0 +1,41 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Big_Oneways Client"=.\client.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "Big_Oneways Server"=.\server.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/TAO/tests/Big_Oneways/Coordinator.cpp b/TAO/tests/Big_Oneways/Coordinator.cpp new file mode 100644 index 00000000000..52fa351d814 --- /dev/null +++ b/TAO/tests/Big_Oneways/Coordinator.cpp @@ -0,0 +1,83 @@ +// +// $Id$ +// +#include "Coordinator.h" + +ACE_RCSID(Big_Oneways, Coordinator, "$Id$") + +Coordinator::Coordinator (CORBA::ULong peer_count) + : peers_ (0) + , peer_count_ (0) + , peer_max_ (peer_count) +{ + ACE_NEW (this->peers_, Test::Peer_var[this->peer_max_]); +} + +Coordinator::~Coordinator (void) +{ + delete[] this->peers_; +} + +int +Coordinator::has_all_peers (void) const +{ + return this->peer_count_ == this->peer_max_; +} + +void +Coordinator::create_session_list (Test::Session_Control_ptr session_control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + Test::Session_List &session_list, + CORBA::Environment &ACE_TRY_ENV) +{ + session_list.length (this->peer_count_); + CORBA::ULong count = 0; + for (Test::Peer_var *i = this->peers_; + i != this->peers_ + this->peer_count_; + ++i) + { + session_list[count++] = + (*i)->create_session (session_control, + payload_size, + thread_count, + message_count, + this->peer_count_, + ACE_TRY_ENV); + ACE_CHECK; + } +} + +void +Coordinator::shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV) +{ + for (Test::Peer_var *i = this->peers_; + i != this->peers_ + this->peer_count_; + ++i) + { + ACE_TRY + { + (*i)->shutdown (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Coordinator::shutdown, ignored"); + } + ACE_ENDTRY; + } +} + +void +Coordinator::add_peer (Test::Peer_ptr peer, + CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + if (this->peer_count_ >= this->peer_max_) + return; + + this->peers_[this->peer_count_++] = + Test::Peer::_duplicate (peer); +} diff --git a/TAO/tests/Big_Oneways/Coordinator.h b/TAO/tests/Big_Oneways/Coordinator.h new file mode 100644 index 00000000000..e754658f952 --- /dev/null +++ b/TAO/tests/Big_Oneways/Coordinator.h @@ -0,0 +1,65 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_COORDINATOR_H +#define BIG_ONEWAYS_COORDINATOR_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Coordinator interface +class Coordinator + : public virtual POA_Test::Coordinator + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Coordinator (CORBA::ULong peer_count); + + /// Destructor + virtual ~Coordinator (void); + + /// Check if all the peers have registered already + int has_all_peers (void) const; + + /// Check a session on each peer + void create_session_list (Test::Session_Control_ptr session_control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + Test::Session_List &session_list, + CORBA::Environment &ACE_TRY_ENV); + + /// Shutdown all the peers + void shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV); + + // = The skeleton methods + virtual void add_peer (Test::Peer_ptr peer, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Store a reference to each peer + Test::Peer_var *peers_; + + /// Current number of elements in the array + size_t peer_count_; + + /// Array's capacity + size_t peer_max_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_COORDINATOR_H */ diff --git a/TAO/tests/Big_Oneways/Makefile b/TAO/tests/Big_Oneways/Makefile new file mode 100644 index 00000000000..46b00dcc5c0 --- /dev/null +++ b/TAO/tests/Big_Oneways/Makefile @@ -0,0 +1,1700 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +LDLIBS = -lTAO + +IDL_FILES = Test +IDL_SRC = TestC.cpp TestS.cpp +BIN = server client + +SRC = $(addsuffix .cpp, $(BIN) Coordinator Peer Session Session_Control Session_Task) $(IDL_SRC) + +CLIENT_OBJS = client.o TestC.o TestS.o Peer.o Session.o Session_Task.o +SERVER_OBJS = server.o TestC.o TestS.o Coordinator.o Session_Control.o + +TAO_IDLFLAGS += -Ge 1 +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), Test$(ext)) + +server: $(addprefix $(VDIR),$(SERVER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CLIENT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), Test$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp Coordinator.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i Session_Control.h \ + $(ACE_ROOT)/ace/Get_Opt.h + +.obj/client.o .obj/client.so .shobj/client.o .shobj/client.so: client.cpp Peer.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i + +.obj/Coordinator.o .obj/Coordinator.so .shobj/Coordinator.o .shobj/Coordinator.so: Coordinator.cpp Coordinator.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i + +.obj/Peer.o .obj/Peer.so .shobj/Peer.o .shobj/Peer.so: Peer.cpp Peer.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i Session.h Session_Task.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Task_T.i + +.obj/Session.o .obj/Session.so .shobj/Session.o .shobj/Session.so: Session.cpp Session.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i Session_Task.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(TAO_ROOT)/tao/debug.h + +.obj/Session_Control.o .obj/Session_Control.so .shobj/Session_Control.o .shobj/Session_Control.so: Session_Control.cpp Session_Control.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i + +.obj/Session_Task.o .obj/Session_Task.so .shobj/Session_Task.o .shobj/Session_Task.so: Session_Task.cpp Session_Task.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Task_T.i \ + Session.h TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i + +.obj/TestC.o .obj/TestC.so .shobj/TestC.o .shobj/TestC.so: TestC.cpp TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/ClientRequestInfo.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + TestC.i + +.obj/TestS.o .obj/TestS.so .shobj/TestS.o .shobj/TestS.so: TestS.cpp TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.h \ + $(ACE_ROOT)/ace/Map.h \ + $(ACE_ROOT)/ace/Map_T.h \ + $(ACE_ROOT)/ace/Pair.h \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Active_Map_Manager.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Map_T.cpp \ + $(ACE_ROOT)/ace/Map_T.i \ + $(TAO_ROOT)/tao/PortableServer/poa_macros.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/PortableServer/Operation_Table.h \ + $(TAO_ROOT)/tao/TAO_Server_Request.h \ + $(TAO_ROOT)/tao/Tagged_Profile.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/IFR_Client_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service_Base.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(ACE_ROOT)/ace/Dynamic_Service.i \ + TestS.i + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/tests/Big_Oneways/Peer.cpp b/TAO/tests/Big_Oneways/Peer.cpp new file mode 100644 index 00000000000..e5cf894acba --- /dev/null +++ b/TAO/tests/Big_Oneways/Peer.cpp @@ -0,0 +1,51 @@ +// +// $Id$ +// +#include "Peer.h" +#include "Session.h" + +ACE_RCSID(Big_Oneways, Peer, "$Id$") + +Peer::Peer (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +Peer::~Peer (void) +{ +} + +Test::Session_ptr +Peer::create_session (Test::Session_Control_ptr control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + CORBA::ULong peer_count, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + Session *session_impl; + ACE_NEW_THROW_EX (session_impl, + Session (control, + payload_size, + thread_count, + message_count, + peer_count), + CORBA::NO_MEMORY ()); + ACE_CHECK_RETURN (Test::Session::_nil ()); + PortableServer::ServantBase_var transfer_ownership (session_impl); + + return session_impl->_this (ACE_TRY_ENV); +} + +void +Peer::shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Peer::shutdown, waiting for threads\n")); + + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Peer::shutdown, shutting down ORB\n")); + this->orb_->shutdown (0, ACE_TRY_ENV); +} diff --git a/TAO/tests/Big_Oneways/Peer.h b/TAO/tests/Big_Oneways/Peer.h new file mode 100644 index 00000000000..ed34b0eb6fa --- /dev/null +++ b/TAO/tests/Big_Oneways/Peer.h @@ -0,0 +1,51 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_PEER_H +#define BIG_ONEWAYS_PEER_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Peer interface +class Peer + : public virtual POA_Test::Peer + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Peer (CORBA::ORB_ptr orb); + + /// Destructor + virtual ~Peer (void); + + // = The skeleton methods + virtual Test::Session_ptr create_session (Test::Session_Control_ptr control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + CORBA::ULong peer_count, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Keep a pointer to the ORB to shutdown cleanly + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_PEER_H */ diff --git a/TAO/tests/Big_Oneways/README b/TAO/tests/Big_Oneways/README new file mode 100644 index 00000000000..ed389e9009c --- /dev/null +++ b/TAO/tests/Big_Oneways/README @@ -0,0 +1,21 @@ +/** + +@page Big_Oneways Test README File + + This is a stress test for the non-blocking I/O features in the +ORB. The test connects multiple peer processes together. Each +process sends messages to all its peers, using multiple threads to +generate the messages. Without non-blocking I/O the system soon +deadlocks. + + This is part of the regression testsuite for: + +http://ace.cs.wustl.edu/bugzilla/show_bug.cgi?id=132 + + To run the test use the run_test.pl script: + +$ ./run_test.pl + + the script returns 0 if the test was successful. + +*/ diff --git a/TAO/tests/Big_Oneways/Session.cpp b/TAO/tests/Big_Oneways/Session.cpp new file mode 100644 index 00000000000..0ce9bd9f2ce --- /dev/null +++ b/TAO/tests/Big_Oneways/Session.cpp @@ -0,0 +1,277 @@ +// +// $Id$ +// +#include "Session.h" +#include "tao/debug.h" + +ACE_RCSID(Big_Oneways, Session, "$Id$") + +Session::Session (Test::Session_Control_ptr control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + CORBA::ULong peer_count) + : control_ (Test::Session_Control::_duplicate (control)) + , running_ (0) + , payload_size_ (payload_size) + , thread_count_ (thread_count) + , message_count_ (message_count) + , active_thread_count_ (0) + , expected_messages_ (thread_count * message_count * (peer_count - 1)) + , task_ (this) + , barrier_ (thread_count + 1) +{ +} + +Session::~Session (void) +{ +} + +int +Session::svc (void) +{ + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::svc, start\n")); + + this->barrier_.wait (); + + /// Automatically decrease the reference count at the end of the + /// thread + PortableServer::ServantBase_var auto_decrement (this); + + ACE_DECLARE_NEW_CORBA_ENV; + + ACE_TRY + { + // Use the same payload over and over + Test::Payload payload (this->payload_size_); + payload.length (this->payload_size_); + + for (CORBA::ULong j = 0; j != this->payload_size_; ++j) + { + payload[j] = j % 256; + } + + // Get the number of peers just once. + CORBA::ULong session_count = + this->other_sessions_.length (); + + this->validate_connections (ACE_TRY_ENV); + ACE_TRY_CHECK; + + for (CORBA::ULong i = 0; i != this->message_count_; ++i) + { +#if 0 + if (i % 500 == 0) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::svc, " + "sending message %d\n", + i)); + } +#endif /* 0 */ + for (CORBA::ULong j = 0; j != session_count; ++j) + { + this->other_sessions_[j]->receive_payload (payload, + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + } + + { + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1); + this->active_thread_count_--; + if (this->more_work ()) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::svc, end\n")); + return 0; + } + } + this->terminate (1, ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Session::svc - "); + return -1; + } + ACE_ENDTRY; + + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::svc, end\n")); + return 0; +} + +void +Session::validate_connections (CORBA::Environment &ACE_TRY_ENV) +{ + CORBA::ULong session_count = + this->other_sessions_.length (); + for (CORBA::ULong i = 0; i != 100; ++i) + { + for (CORBA::ULong j = 0; j != session_count; ++j) + { + ACE_TRY + { + this->other_sessions_[j]->ping (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY {} ACE_ENDTRY; + } + } + ACE_DEBUG ((LM_DEBUG, "(%P|%t) connections are ready\n")); +} + +void +Session::start (const Test::Session_List &other_sessions, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException, + Test::Already_Running, + Test::No_Peers)) +{ + if (other_sessions.length () == 0) + ACE_THROW (Test::No_Peers ()); + + { + ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); + if (this->running_) + ACE_THROW (Test::Already_Running ()); + + this->other_sessions_ = other_sessions; + + for (CORBA::ULong i = 0; i != this->thread_count_; ++i) + { + // Increase the reference count because the new thread will have + // access to this object.... + ACE_TRY + { + this->_add_ref (ACE_TRY_ENV); + ACE_TRY_CHECK; + if (this->task_.activate ( + THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) + { + this->_remove_ref (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + else + { + this->running_ = 1; + this->active_thread_count_++; + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Session::start, ignored"); + } + ACE_ENDTRY; + } + + if (this->active_thread_count_ != this->thread_count_) + return; + + this->barrier_.wait (); + + if (this->running_ != 0) + return; + } + /// None of the threads are running, this session is useless at + /// this point, report the problem and destroy the local objects + this->terminate (0, ACE_TRY_ENV); +} + +void +Session::ping (CORBA::Environment &) ACE_THROW_SPEC (()) +{ +} + +void +Session::receive_payload (const Test::Payload &the_payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + if (the_payload.length () != this->payload_size_) + { + ACE_ERROR ((LM_ERROR, + "ERROR: (%P|%t) Session::receive_payload, " + "unexpected payload size (%d != %d)\n", + the_payload.length (), this->payload_size_)); + } + + { + ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); + this->expected_messages_--; + + int verbose = 0; +#if 0 + verbose = this->expected_messages_ % 500 == 0; + if (this->expected_messages_ < 500) + verbose = (this->expected_messages_ % 100 == 0); + if (this->expected_messages_ < 100) + verbose = (this->expected_messages_ % 10 == 0); +#endif /* 0 */ + if (this->expected_messages_ < 5) + verbose = 1; + + if (verbose) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::receive_payload, " + "%d messages to go\n", + this->expected_messages_)); + } + if (this->more_work ()) + return; + } + this->terminate (1, ACE_TRY_ENV); +} + + +void +Session::destroy (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Make sure local resources are released + + PortableServer::POA_var poa = + this->_default_POA (ACE_TRY_ENV); + ACE_CHECK; + PortableServer::ObjectId_var oid = + poa->servant_to_id (this, ACE_TRY_ENV); + ACE_CHECK; + poa->deactivate_object (oid.in (), ACE_TRY_ENV); + ACE_CHECK; +} + +int +Session::more_work (void) const +{ + if (this->expected_messages_ > 0 + || this->active_thread_count_ > 0 + || this->running_ == 0) + return 1; + + return 0; +} + +void +Session::terminate (CORBA::Boolean success, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC (()) +{ + // Make sure that global resources are released + ACE_TRY_EX(GLOBAL) + { + this->control_->session_finished (success, + ACE_TRY_ENV); + ACE_TRY_CHECK_EX(GLOBAL); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Session::terminate, ignored"); + } + ACE_ENDTRY; + +} diff --git a/TAO/tests/Big_Oneways/Session.h b/TAO/tests/Big_Oneways/Session.h new file mode 100644 index 00000000000..71a05cbe5d1 --- /dev/null +++ b/TAO/tests/Big_Oneways/Session.h @@ -0,0 +1,110 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_SESSION_H +#define BIG_ONEWAYS_SESSION_H +#include "ace/pre.h" + +#include "TestS.h" +#include "Session_Task.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Session interface +class Session + : public virtual POA_Test::Session + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Session (Test::Session_Control_ptr control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + CORBA::ULong peer_count); + + /// Destructor + virtual ~Session (void); + + /// Run one of the experiment threads + int svc (void); + + // = The skeleton methods + virtual void start (const Test::Session_List &other_sessions, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException, + Test::Already_Running, + Test::No_Peers)); + + virtual void ping (CORBA::Environment &) ACE_THROW_SPEC (()); + + virtual void receive_payload (const Test::Payload &the_payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void destroy (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Helper function used to report any problems and destroy local + /// resources + void terminate (CORBA::Boolean success, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC (()); + + /// Return 1 if all the work in this session has been completed + int more_work (void) const; + + /// Make sure that all threads have connections avaiable to the + /// other sessions. + void validate_connections (CORBA::Environment &ACE_TRY_ENV); + +private: + /// Synchronize the internal state + ACE_SYNCH_MUTEX mutex_; + + /// Keep a reference to the Session_Control, this is used to report + /// when the test finishes. + Test::Session_Control_var control_; + + /// Keep track of wether the test is running. + int running_; + + /// The other session objects participating in the test + Test::Session_List other_sessions_; + + /// Size of each message + CORBA::ULong payload_size_; + + /// Number of threads + CORBA::ULong thread_count_; + + /// Number of messages to send + CORBA::ULong message_count_; + + /// The number of threads currently running, when this reaches 0 the + /// session destroys itself. + CORBA::ULong active_thread_count_; + + /// Number of messages expected + CORBA::ULong expected_messages_; + + /// Helper class to run svc() in a separate thread + Session_Task task_; + + /// Barrier to start all threads simultaenously + ACE_Thread_Barrier barrier_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_SESSION_H */ diff --git a/TAO/tests/Big_Oneways/Session_Control.cpp b/TAO/tests/Big_Oneways/Session_Control.cpp new file mode 100644 index 00000000000..f0f5c3bd4b4 --- /dev/null +++ b/TAO/tests/Big_Oneways/Session_Control.cpp @@ -0,0 +1,75 @@ +// +// $Id$ +// +#include "Session_Control.h" + +ACE_RCSID(Big_Oneways, Session_Control, "$Id$") + +Session_Control::Session_Control (CORBA::ULong session_count) + : session_count_ (session_count) + , success_ (1) +{ +} + +int +Session_Control::all_sessions_finished (void) const +{ + return this->session_count_ == 0; +} + +Session_Control::~Session_Control (void) +{ + if (this->session_count_ == 0 && this->success_) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session_Control::~Session_control, " + " good, all sessions did finish\n")); + } + else if (session_count_ != 0) + { + ACE_ERROR ((LM_ERROR, + "ERROR: (%P|%t) Session_Control::~Session_control, " + " %d sessions did not finish\n", + this->session_count_)); + } + else + { + ACE_ERROR ((LM_ERROR, + "ERROR: (%P|%t) Session_Control::~Session_control, " + " some sessions failed\n")); + } +} + +void +Session_Control::session_finished (CORBA::Boolean success, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); + if (this->session_count_ == 0) + { + ACE_ERROR ((LM_ERROR, + "ERROR: (%P|%t) Session_Control::session_finished, " + "unexpected callback\n")); + } + if (success == 0) + this->success_ = 0; + + this->session_count_--; + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session_Control::session_finished, " + "%d sessions to go\n", + this->session_count_)); + if (session_count_ == 0) + { + PortableServer::POA_var poa = + this->_default_POA (ACE_TRY_ENV); + ACE_CHECK; + PortableServer::ObjectId_var oid = + poa->servant_to_id (this, ACE_TRY_ENV); + ACE_CHECK; + poa->deactivate_object (oid.in (), ACE_TRY_ENV); + ACE_CHECK; + } + +} diff --git a/TAO/tests/Big_Oneways/Session_Control.h b/TAO/tests/Big_Oneways/Session_Control.h new file mode 100644 index 00000000000..09c19dbaaba --- /dev/null +++ b/TAO/tests/Big_Oneways/Session_Control.h @@ -0,0 +1,57 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_SESSION_CONTROL_H +#define BIG_ONEWAYS_SESSION_CONTROL_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Session_Control interface +class Session_Control + : public virtual POA_Test::Session_Control + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + /** + * @param session_count Number of session objects in the experiment. + */ + Session_Control (CORBA::ULong session_count); + + /// Destructor + virtual ~Session_Control (void); + + /// Return 1 when all sessions have finished + int all_sessions_finished (void) const; + + // = The skeleton methods + virtual void session_finished (CORBA::Boolean success, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Synchronize the internal state + ACE_SYNCH_MUTEX mutex_; + + /// The type of test + CORBA::ULong session_count_; + + /// Set to falso if any session reported a failure + CORBA::Boolean success_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_SESSION_CONTROL_H */ diff --git a/TAO/tests/Big_Oneways/Session_Task.cpp b/TAO/tests/Big_Oneways/Session_Task.cpp new file mode 100644 index 00000000000..bd992a66e5d --- /dev/null +++ b/TAO/tests/Big_Oneways/Session_Task.cpp @@ -0,0 +1,19 @@ +// +// $Id$ +// + +#include "Session_Task.h" +#include "Session.h" + +ACE_RCSID(Big_Oneways, Session_Task, "$Id$") + +Session_Task::Session_Task (Session *session) + : session_ (session) +{ +} + +int +Session_Task::svc (void) +{ + return this->session_->svc (); +} diff --git a/TAO/tests/Big_Oneways/Session_Task.h b/TAO/tests/Big_Oneways/Session_Task.h new file mode 100644 index 00000000000..2ef3bf69925 --- /dev/null +++ b/TAO/tests/Big_Oneways/Session_Task.h @@ -0,0 +1,33 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_SESSION_TASK_H +#define BIG_ONEWAYS_SESSION_TASK_H +#include "ace/pre.h" + +#include "ace/Task.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class Session; + +/// Implement a Task to run the experiments using multiple threads. +class Session_Task : public ACE_Task_Base +{ +public: + /// Constructor + Session_Task (Session *session); + + /// Thread entry point + int svc (void); + +private: + /// Reference to the test interface + Session *session_; +}; + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_SESSION_TASK_H */ diff --git a/TAO/tests/Big_Oneways/Test.idl b/TAO/tests/Big_Oneways/Test.idl new file mode 100644 index 00000000000..60065cf85fc --- /dev/null +++ b/TAO/tests/Big_Oneways/Test.idl @@ -0,0 +1,83 @@ +// +// $Id$ +// + +module Test +{ + /// The message type, just used to send a lot of data on each + /// request + typedef sequence<octet> Payload; + + /// A session is a single instance of the test + interface Session; + typedef sequence<Session> Session_List; + + /// A session control is used to determine if all the Session in an + /// experiment have finished. + /** + * @param success If false then the session failed, the experiment + * is successful only if all sessions finish successfully + */ + interface Session_Control + { + void session_finished (in boolean success); + }; + + /// A Peer is used to create sessions + interface Peer + { + /// Create a new session + /** + * @param payload_size The size of each message + * @param thread_count The number of threads that each session + * must create + * @param message_count How many messages does each thread send. + */ + Session create_session (in Session_Control control, + in unsigned long payload_size, + in unsigned long thread_count, + in unsigned long message_count, + in unsigned long peer_count); + + /// Shutdown the peer + oneway void shutdown (); + }; + + /// The Session already has an experiment running. + exception Already_Running {}; + + /// The experiment requires at least two Sessions + exception No_Peers {}; + + interface Session + { + /// Start the test, send messages to all the peers + /** + * @param other_sessions The list of sessions participating in the + * experiment, this list must not include the session + * receiving the start() call. + */ + void start (in Session_List other_sessions) + raises (Already_Running, No_Peers); + + /// Ping the session, used to validate all connections + void ping (); + + /// Receive the payload + oneway void receive_payload (in Payload the_payload); + + /// Destroy the Session object + void destroy (); + }; + + interface Coordinator + { + /// Add a new peer. + /** + * The coordinator starts the test by calling <send_oneways> on + * all peers. How does it decide to do that is application + * specific. + */ + void add_peer (in Peer the_peer); + }; +}; diff --git a/TAO/tests/Big_Oneways/client.cpp b/TAO/tests/Big_Oneways/client.cpp new file mode 100644 index 00000000000..542c9ed70ed --- /dev/null +++ b/TAO/tests/Big_Oneways/client.cpp @@ -0,0 +1,116 @@ +// $Id$ + +#include "Peer.h" +#include "ace/Get_Opt.h" +#include "ace/Thread_Manager.h" + +ACE_RCSID(Big_Oneways, client, "$Id$") + +const char *ior = "file://test.ior"; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "k:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'k': + ior = get_opts.optarg; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + ACE_TRY_CHECK; + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (poa_object.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Panic got a nil RootPOA\n"), + 1); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var tmp = + orb->string_to_object(ior, ACE_TRY_ENV); + ACE_TRY_CHECK; + + Test::Coordinator_var coordinator = + Test::Coordinator::_narrow(tmp.in (), ACE_TRY_ENV); + if (CORBA::is_nil (coordinator.in ())) + { + ACE_ERROR_RETURN ((LM_DEBUG, + "Nil coordinator reference <%s>\n", + ior), + 1); + } + + Peer *peer_impl; + ACE_NEW_RETURN (peer_impl, + Peer (orb.in ()), + 1); + PortableServer::ServantBase_var peer_owner_transfer(peer_impl); + + Test::Peer_var peer = + peer_impl->_this (ACE_TRY_ENV); + + poa_manager->activate (ACE_TRY_ENV); + ACE_TRY_CHECK; + + coordinator->add_peer (peer.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->run (ACE_TRY_ENV); + ACE_TRY_CHECK; + + // Wait for all the threads. + ACE_Thread_Manager::instance ()->wait (); + + root_poa->destroy (1, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/Big_Oneways/client.dsp b/TAO/tests/Big_Oneways/client.dsp new file mode 100644 index 00000000000..46f4d73be04 --- /dev/null +++ b/TAO/tests/Big_Oneways/client.dsp @@ -0,0 +1,232 @@ +# Microsoft Developer Studio Project File - Name="Big_Oneways Client" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Big_Oneways Client - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak" CFG="Big_Oneways Client - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Big_Oneways Client - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Big_Oneways Client - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Big_Oneways Client - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../../" /I "../../" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 TAO.lib TAO_PortableServer.lib ace.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ELSEIF "$(CFG)" == "Big_Oneways Client - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "../../../" /I "../../" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 TAOd.lib TAO_PortableServerd.lib aced.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ENDIF
+
+# Begin Target
+
+# Name "Big_Oneways Client - Win32 Release"
+# Name "Big_Oneways Client - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Peer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Session.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Session_Task.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ".h"
+# Begin Source File
+
+SOURCE=.\Peer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Session.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Session_Task.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\Test.idl
+
+!IF "$(CFG)" == "Big_Oneways Client - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "Big_Oneways Client - Win32 Debug"
+
+USERDEP__TEST_="..\..\..\bin\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Inline Files"
+
+# PROP Default_Filter ".i"
+# Begin Source File
+
+SOURCE=.\TestC.i
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.i
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/tests/Big_Oneways/run_test.pl b/TAO/tests/Big_Oneways/run_test.pl new file mode 100755 index 00000000000..a272f7d976d --- /dev/null +++ b/TAO/tests/Big_Oneways/run_test.pl @@ -0,0 +1,78 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; +use Getopt::Std; + +local ($opt_i, $opt_b); + +if (!getopts ('i:b:')) { + print "Usage: run_test.pl [-b payload_size] [-i iterations]\n"; + exit 1; +} + +my $server_args = " -p 3"; +if (defined $opt_i) { + $server_args .= " -i ".$opt_i; +} +if (defined $opt_b) { + $server_args .= " -b ".$opt_b; +} + +$iorfile = PerlACE::LocalFile ("server.ior"); + +unlink $iorfile; +$SV = new PerlACE::Process ("server", "-o $iorfile $server_args"); +$CL1 = new PerlACE::Process ("client", " -k file://$iorfile"); +$CL2 = new PerlACE::Process ("client", " -k file://$iorfile"); +$CL3 = new PerlACE::Process ("client", " -k file://$iorfile"); + + +$SV->Spawn (); + +if (PerlACE::waitforfile_timed ($iorfile, 15) == -1) { + print STDERR "ERROR: cannot find file <$iorfile>\n"; + $SV->Kill (); $SV->TimedWait (1); + exit 1; +} + +$CL1->Spawn (); +$CL2->Spawn (); +$CL3->Spawn (); + +$client1 = $CL1->WaitKill (300); + +if ($client1 != 0) { + print STDERR "ERROR: client 1 returned $client1\n"; + $status = 1; +} + +$client2 = $CL2->WaitKill (300); + +if ($client2 != 0) { + print STDERR "ERROR: client 2 returned $client2\n"; + $status = 1; +} + +$client3 = $CL3->WaitKill (300); + +if ($client3 != 0) { + print STDERR "ERROR: client 3 returned $client3\n"; + $status = 1; +} + +$server = $SV->TerminateWaitKill (5); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; +} + +unlink $iorfile; + +exit $status; diff --git a/TAO/tests/Big_Oneways/server.cpp b/TAO/tests/Big_Oneways/server.cpp new file mode 100644 index 00000000000..b09e4283d0c --- /dev/null +++ b/TAO/tests/Big_Oneways/server.cpp @@ -0,0 +1,218 @@ +// $Id$ + +#include "Coordinator.h" +#include "Session_Control.h" +#include "ace/Get_Opt.h" + +ACE_RCSID(Big_Oneways, server, "$Id$") + +const char *ior_output_file = "test.ior"; +CORBA::ULong peer_count = 4; +CORBA::ULong payload_size = 1024; +CORBA::ULong message_count = 1000; +CORBA::ULong thread_count = 4; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "o:p:b:i:n:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + ior_output_file = get_opts.optarg; + break; + + case 'p': + peer_count = ACE_OS::atoi (get_opts.optarg); + break; + + case 'b': + payload_size = ACE_OS::atoi (get_opts.optarg); + break; + + case 'i': + message_count = ACE_OS::atoi (get_opts.optarg); + break; + + case 'n': + thread_count = ACE_OS::atoi (get_opts.optarg); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-o <iorfile> " + "-p <peer_count> " + "-b <payload_size> " + "-i <message_count> " + "-n <thread_count> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + ACE_TRY_CHECK; + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (poa_object.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Panic got a nil RootPOA\n"), + 1); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Coordinator *coordinator_impl; + ACE_NEW_RETURN (coordinator_impl, + Coordinator (peer_count), + 1); + PortableServer::ServantBase_var coordinator_owner_transfer(coordinator_impl); + + Test::Coordinator_var coordinator = + coordinator_impl->_this (ACE_TRY_ENV); + + CORBA::String_var ior = + orb->object_to_string (coordinator.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + // If the ior_output_file exists, output the ior to it + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + + poa_manager->activate (ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "Waiting for peers . . . ")); + for (int i = 0; + i != 60 && !coordinator_impl->has_all_peers (); + ++i) + { + ACE_Time_Value tv (1, 0); + orb->run (tv, ACE_TRY_ENV); + } + ACE_DEBUG ((LM_DEBUG, "done.\n")); + + if (!coordinator_impl->has_all_peers ()) + { + ACE_ERROR ((LM_DEBUG, + "ERROR: timeout, some peers failed to register\n")); + return 1; + } + + Session_Control *session_control_impl; + ACE_NEW_RETURN (session_control_impl, + Session_Control (peer_count), + 1); + PortableServer::ServantBase_var session_control_owner_transfer(session_control_impl); + + Test::Session_Control_var session_control = + session_control_impl->_this (ACE_TRY_ENV); + + Test::Session_List session_list; + coordinator_impl->create_session_list (session_control.in (), + payload_size, + thread_count, + message_count, + session_list, + ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_ASSERT (session_list.length () == peer_count); + + CORBA::ULong j; + for (j = 0; j != peer_count; ++j) + { + // Make a copy of the sessions, excluding the j-th element + Test::Session_List other_sessions (peer_count - 1); + other_sessions.length (peer_count - 1); + CORBA::ULong count = 0; + for (CORBA::ULong k = 0; k != peer_count; ++k) + { + if (k == j) + continue; + other_sessions[count++] = + Test::Session::_duplicate (session_list[k]); + } + + session_list[j]->start (other_sessions, + ACE_TRY_ENV); + ACE_TRY_CHECK; + + } + + ACE_DEBUG ((LM_DEBUG, "Waiting for sessions . . . \n")); + for (int k = 0; + k != 300 && !session_control_impl->all_sessions_finished (); + ++k) + { + ACE_Time_Value tv (1, 0); + orb->run (tv, ACE_TRY_ENV); + ACE_TRY_CHECK; + } + + if (!session_control_impl->all_sessions_finished ()) + { + ACE_ERROR ((LM_ERROR, + "ERROR: timeout waiting for sessions\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "All sessions finished . . . \n")); + + for (j = 0; j != peer_count; ++j) + { + session_list[j]->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + + } + + coordinator_impl->shutdown_all_peers (ACE_TRY_ENV); + ACE_TRY_CHECK; + + root_poa->destroy (1, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/Big_Oneways/server.dsp b/TAO/tests/Big_Oneways/server.dsp new file mode 100644 index 00000000000..5c8ad88f157 --- /dev/null +++ b/TAO/tests/Big_Oneways/server.dsp @@ -0,0 +1,224 @@ +# Microsoft Developer Studio Project File - Name="Big_Oneways Server" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Big_Oneways Server - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak" CFG="Big_Oneways Server - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Big_Oneways Server - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Big_Oneways Server - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Big_Oneways Server - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../../" /I "../../" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 TAO.lib TAO_PortableServer.lib ace.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ELSEIF "$(CFG)" == "Big_Oneways Server - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "../../../" /I "../../" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 TAOd.lib TAO_PortableServerd.lib aced.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ENDIF
+
+# Begin Target
+
+# Name "Big_Oneways Server - Win32 Release"
+# Name "Big_Oneways Server - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\Coordinator.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Session_Control.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ".h"
+# Begin Source File
+
+SOURCE=.\Coordinator.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Session_Control.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\Test.idl
+
+!IF "$(CFG)" == "Big_Oneways Server - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "Big_Oneways Server - Win32 Debug"
+
+USERDEP__TEST_="..\..\..\bin\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Inline Files"
+
+# PROP Default_Filter ".i"
+# Begin Source File
+
+SOURCE=.\TestC.i
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.i
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/tests/Big_Request_Muxing/Big_Request_Muxing.dsw b/TAO/tests/Big_Request_Muxing/Big_Request_Muxing.dsw new file mode 100644 index 00000000000..8d2d7675f89 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/Big_Request_Muxing.dsw @@ -0,0 +1,41 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Big_Request_Muxing Client"=.\client.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "Big_Request_Muxing Server"=.\server.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/TAO/tests/Big_Request_Muxing/Client_Task.cpp b/TAO/tests/Big_Request_Muxing/Client_Task.cpp new file mode 100644 index 00000000000..cdb06663c5e --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/Client_Task.cpp @@ -0,0 +1,89 @@ +// +// $Id$ +// + +#include "Client_Task.h" + +ACE_RCSID(Big_Request_Muxing, Client_Task, "$Id$") + +Client_Task::Client_Task (ACE_Thread_Manager *thr_mgr, + Test::Payload_Receiver_ptr payload_receiver, + CORBA::Long event_count, + CORBA::ULong event_size, + CORBA::ORB_ptr orb, + Messaging::SyncScope sync_scope) + : ACE_Task_Base (thr_mgr) + , payload_receiver_ (Test::Payload_Receiver::_duplicate (payload_receiver)) + , event_count_ (event_count) + , event_size_ (event_size) + , orb_ (CORBA::ORB::_duplicate (orb)) + , sync_scope_ (sync_scope) +{ +} + +int +Client_Task::svc (void) +{ + Test::Payload payload (this->event_size_); + payload.length (this->event_size_); + + for (CORBA::ULong j = 0; j != payload.length (); ++j) + payload[j] = (j % 256); + + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + this->validate_connection (ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var object = + this->orb_->resolve_initial_references ("PolicyCurrent", + ACE_TRY_ENV); + ACE_TRY_CHECK; + CORBA::PolicyCurrent_var policy_current = + CORBA::PolicyCurrent::_narrow (object.in (), ACE_TRY_ENV); + + CORBA::Any scope_as_any; + scope_as_any <<= this->sync_scope_; + + + CORBA::PolicyList policy_list (1); + policy_list.length (1); + policy_list[0] = + this->orb_->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, + scope_as_any, + ACE_TRY_ENV); + ACE_TRY_CHECK; + + policy_current->set_policy_overrides (policy_list, + CORBA::ADD_OVERRIDE, + ACE_TRY_ENV); + ACE_TRY_CHECK; + + for (int i = 0; i != this->event_count_; ++i) + { + this->payload_receiver_->more_data (payload, ACE_TRY_ENV); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + return -1; + } + ACE_ENDTRY; + return 0; +} + +void +Client_Task::validate_connection (CORBA::Environment &ACE_TRY_ENV) +{ + ACE_TRY + { + for (int i = 0; i != 100; ++i) + { + (void) this->payload_receiver_->get_message_count (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY {} ACE_ENDTRY; +} diff --git a/TAO/tests/Big_Request_Muxing/Client_Task.h b/TAO/tests/Big_Request_Muxing/Client_Task.h new file mode 100644 index 00000000000..8bb3bc69cfb --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/Client_Task.h @@ -0,0 +1,56 @@ +// +// $Id$ +// + +#ifndef BIG_REQUEST_MUXING_CLIENT_TASK_H +#define BIG_REQUEST_MUXING_CLIENT_TASK_H +#include "ace/pre.h" + +#include "TestC.h" +// #include "tao/Messaging.h" +#include "ace/Task.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +/// Implement a Task to run the experiments using multiple threads. +class Client_Task : public ACE_Task_Base +{ +public: + /// Constructor + Client_Task (ACE_Thread_Manager *thr_mgr, + Test::Payload_Receiver_ptr receiver, + CORBA::Long event_count, + CORBA::ULong event_size, + CORBA::ORB_ptr orb, + Messaging::SyncScope sync_scope); + + /// Thread entry point + int svc (void); + +private: + /// Make sure that all threads have connections available to + /// workaround bug 189 + void validate_connection (CORBA::Environment &ACE_TRY_ENV); + +private: + /// Reference to the test interface + Test::Payload_Receiver_var payload_receiver_; + + /// Total number of events + CORBA::Long event_count_; + + /// Size of each message + CORBA::ULong event_size_; + + /// Keep a reference to the ORB, used to initialize the SyncScope + /// policy + CORBA::ORB_var orb_; + + /// The SyncScope used in this Task + Messaging::SyncScope sync_scope_; +}; + +#include "ace/post.h" +#endif /* BIG_REQUEST_MUXING_CLIENT_TASK_H */ diff --git a/TAO/tests/Big_Request_Muxing/Makefile b/TAO/tests/Big_Request_Muxing/Makefile new file mode 100644 index 00000000000..54f2eb56db7 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/Makefile @@ -0,0 +1,1173 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +LDLIBS = -lTAO + +IDL_FILES = Test +IDL_SRC = TestC.cpp TestS.cpp +BIN = server client + +SRC = $(addsuffix .cpp, $(BIN) Client_Task Payload_Receiver) $(IDL_SRC) + +CLIENT_OBJS = client.o TestC.o Client_Task.o +SERVER_OBJS = server.o TestC.o TestS.o Payload_Receiver.o + +TAO_IDLFLAGS += -Ge 1 +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), Test$(ext)) + +server: $(addprefix $(VDIR),$(SERVER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CLIENT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), Test$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp Payload_Receiver.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i \ + $(ACE_ROOT)/ace/Get_Opt.h + +.obj/client.o .obj/client.so .shobj/client.o .shobj/client.so: client.cpp Client_Task.h \ + $(ACE_ROOT)/ace/pre.h \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Get_Opt.h + +.obj/Client_Task.o .obj/Client_Task.so .shobj/Client_Task.o .shobj/Client_Task.so: Client_Task.cpp Client_Task.h \ + $(ACE_ROOT)/ace/pre.h \ + TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Task_T.i + +.obj/Payload_Receiver.o .obj/Payload_Receiver.so .shobj/Payload_Receiver.o .shobj/Payload_Receiver.so: Payload_Receiver.cpp Payload_Receiver.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i + +.obj/TestC.o .obj/TestC.so .shobj/TestC.o .shobj/TestC.so: TestC.cpp TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/ClientRequestInfo.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + TestC.i + +.obj/TestS.o .obj/TestS.so .shobj/TestS.o .shobj/TestS.so: TestS.cpp TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.h \ + $(ACE_ROOT)/ace/Map.h \ + $(ACE_ROOT)/ace/Map_T.h \ + $(ACE_ROOT)/ace/Pair.h \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Active_Map_Manager.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Map_T.cpp \ + $(ACE_ROOT)/ace/Map_T.i \ + $(TAO_ROOT)/tao/PortableServer/poa_macros.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/PortableServer/Operation_Table.h \ + $(TAO_ROOT)/tao/TAO_Server_Request.h \ + $(TAO_ROOT)/tao/Tagged_Profile.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/IFR_Client_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service_Base.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(ACE_ROOT)/ace/Dynamic_Service.i \ + TestS.i + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/tests/Big_Request_Muxing/Payload_Receiver.cpp b/TAO/tests/Big_Request_Muxing/Payload_Receiver.cpp new file mode 100644 index 00000000000..a4179b53960 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/Payload_Receiver.cpp @@ -0,0 +1,28 @@ +// +// $Id$ +// +#include "Payload_Receiver.h" + +ACE_RCSID(Big_Request_Muxing, Payload_Receiver, "$Id$") + +Payload_Receiver::Payload_Receiver (void) + : message_count_ (0) + , byte_count_ (0) +{ +} + +void +Payload_Receiver::more_data (const Test::Payload &payload, + CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->message_count_++; + this->byte_count_ += payload.length (); +} + +CORBA::Long +Payload_Receiver::get_message_count (CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return this->message_count_; +} diff --git a/TAO/tests/Big_Request_Muxing/Payload_Receiver.h b/TAO/tests/Big_Request_Muxing/Payload_Receiver.h new file mode 100644 index 00000000000..73787c62451 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/Payload_Receiver.h @@ -0,0 +1,50 @@ +// +// $Id$ +// + +#ifndef BIG_REQUEST_MUXING_PAYLOAD_RECEIVER_H +#define BIG_REQUEST_MUXING_PAYLOAD_RECEIVER_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Payload_Receiver interface +/** + * Simply print count how many bytes were received. + */ +class Payload_Receiver + : public virtual POA_Test::Payload_Receiver + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Payload_Receiver (void); + + // = The skeleton methods + virtual void more_data (const Test::Payload &payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual CORBA::Long get_message_count (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Count the number of messages received + CORBA::ULong message_count_; + + /// Count the number of bytes received + CORBA::ULong byte_count_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_REQUEST_MUXING_PAYLOAD_RECEIVER_H */ diff --git a/TAO/tests/Big_Request_Muxing/README b/TAO/tests/Big_Request_Muxing/README new file mode 100644 index 00000000000..227c7d2ce71 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/README @@ -0,0 +1,24 @@ +/** + +@page Big_Request_Muxing Test README File + + This is a stress test for the non-blocking I/O features in the +ORB when used to send oneways and reliable oneways. A client process +creates multiple threads, each thread sends (large) oneway requests +with different levels of reliability. The main thread runs the ORB +event loop. The thread also configures connection muxing in the ORB, +forcing all the threads to share the same connection. This level of +concurrency is designed to test as many code sequences in the ORB +output data as possible. + + This is part of the regression testsuite for: + +http://ace.cs.wustl.edu/bugzilla/show_bug.cgi?id=132 + + To run the test use the run_test.pl script: + +$ ./run_test.pl + + the script returns 0 if the test was successful. + +*/ diff --git a/TAO/tests/Big_Request_Muxing/Test.idl b/TAO/tests/Big_Request_Muxing/Test.idl new file mode 100644 index 00000000000..167d8513c63 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/Test.idl @@ -0,0 +1,17 @@ +// +// $Id$ +// + +module Test +{ + typedef sequence<octet> Payload; + + interface Payload_Receiver + { + /// Send the data using a twoway operat + oneway void more_data (in Payload the_payload); + + /// Return the number of messages received so far + long get_message_count (); + }; +}; diff --git a/TAO/tests/Big_Request_Muxing/client.cpp b/TAO/tests/Big_Request_Muxing/client.cpp new file mode 100644 index 00000000000..38a06a91e97 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/client.cpp @@ -0,0 +1,123 @@ +// $Id$ + +#include "Client_Task.h" +#include "ace/Get_Opt.h" + +ACE_RCSID(Muxing, client, "$Id$") + +const char *ior = "file://test.ior"; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "k:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'k': + ior = get_opts.optarg; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior>" + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var tmp = + orb->string_to_object(ior, ACE_TRY_ENV); + ACE_TRY_CHECK; + + Test::Payload_Receiver_var payload_receiver = + Test::Payload_Receiver::_narrow(tmp.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (payload_receiver.in ())) + { + ACE_ERROR_RETURN ((LM_DEBUG, + "Nil coordinator reference <%s>\n", + ior), + 1); + } + + + Client_Task task0 (ACE_Thread_Manager::instance (), + payload_receiver.in (), + 1000, + 4096, + orb.in (), + Messaging::SYNC_WITH_TARGET); + Client_Task task1 (ACE_Thread_Manager::instance (), + payload_receiver.in (), + 1000, + 4096, + orb.in (), + Messaging::SYNC_WITH_TRANSPORT); + Client_Task task2 (ACE_Thread_Manager::instance (), + payload_receiver.in (), + 1000, + 4096, + orb.in (), + Messaging::SYNC_NONE); + + ACE_DEBUG ((LM_DEBUG, "(%P) Activating threads\n")); + if (task0.activate (THR_NEW_LWP | THR_JOINABLE, 2, 1) == -1) + { + ACE_ERROR ((LM_ERROR, "Error activating client task\n")); + } + if (task1.activate (THR_NEW_LWP | THR_JOINABLE, 2, 1) == -1) + { + ACE_ERROR ((LM_ERROR, "Error activating client task\n")); + } + if (task2.activate (THR_NEW_LWP | THR_JOINABLE, 2, 1) == -1) + { + ACE_ERROR ((LM_ERROR, "Error activating client task\n")); + } + + ACE_Time_Value tv (120, 0); + orb->run (tv, ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_Thread_Manager::instance ()->wait (); + ACE_DEBUG ((LM_DEBUG, "(%P) Threads finished\n")); + + CORBA::Long count = + payload_receiver->get_message_count (ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P) - Payload_Receiver got %d messages\n", + count)); + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/Big_Request_Muxing/client.dsp b/TAO/tests/Big_Request_Muxing/client.dsp new file mode 100644 index 00000000000..cdef9e7e7f6 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/client.dsp @@ -0,0 +1,212 @@ +# Microsoft Developer Studio Project File - Name="Big_Request_Muxing Client" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Big_Request_Muxing Client - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak" CFG="Big_Request_Muxing Client - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Big_Request_Muxing Client - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Big_Request_Muxing Client - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Big_Request_Muxing Client - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../../" /I "../../" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 TAO.lib TAO_PortableServer.lib ace.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ELSEIF "$(CFG)" == "Big_Request_Muxing Client - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "../../../" /I "../../" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 TAOd.lib TAO_PortableServerd.lib aced.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ENDIF
+
+# Begin Target
+
+# Name "Big_Request_Muxing Client - Win32 Release"
+# Name "Big_Request_Muxing Client - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Client_Task.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestC.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ".h"
+# Begin Source File
+
+SOURCE=.\Client_Task.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\Test.idl
+
+!IF "$(CFG)" == "Big_Request_Muxing Client - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "Big_Request_Muxing Client - Win32 Debug"
+
+USERDEP__TEST_="..\..\..\bin\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Inline Files"
+
+# PROP Default_Filter ".i"
+# Begin Source File
+
+SOURCE=.\TestC.i
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.i
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/tests/Big_Request_Muxing/run_test.pl b/TAO/tests/Big_Request_Muxing/run_test.pl new file mode 100755 index 00000000000..8c7fea7d379 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/run_test.pl @@ -0,0 +1,52 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; + +$iorfile = PerlACE::LocalFile ("server.ior"); +unlink $iorfile; + +$SV = new PerlACE::Process ("server", "-o $iorfile"); +$CL1 = new PerlACE::Process ("client", " -k file://$iorfile"); +$CL2 = new PerlACE::Process ("client", " -k file://$iorfile"); + +$SV->Spawn (); + +if (PerlACE::waitforfile_timed ($iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$iorfile>\n"; + $SV->Kill (); $SV->TimedWait (1); + exit 1; +} + +$CL1->Spawn (60); +$CL2->Spawn (60); + +$client1 = $CL1->WaitKill (300); + +if ($client1 != 0) { + print STDERR "ERROR: client 1 returned $client1\n"; + $status = 1; +} + +$client2 = $CL2->WaitKill (300); + +if ($client2 != 0) { + print STDERR "ERROR: client 2 returned $client2\n"; + $status = 1; +} + +$server = $SV->TerminateWaitKill (5); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; +} + +unlink $iorfile; + +exit $status; diff --git a/TAO/tests/Big_Request_Muxing/server.cpp b/TAO/tests/Big_Request_Muxing/server.cpp new file mode 100644 index 00000000000..fb64629eb8d --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/server.cpp @@ -0,0 +1,112 @@ +// $Id$ + +#include "Payload_Receiver.h" +#include "ace/Get_Opt.h" + +ACE_RCSID(Big_Request_Muxing, server, "$Id$") + +const char *ior_output_file = "test.ior"; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "o:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + ior_output_file = get_opts.optarg; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-o <iorfile>" + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (poa_object.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize the POA.\n"), + 1); + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Payload_Receiver *payload_receiver_impl; + ACE_NEW_RETURN (payload_receiver_impl, + Payload_Receiver, + 1); + PortableServer::ServantBase_var receiver_owner_transfer(payload_receiver_impl); + + Test::Payload_Receiver_var payload_receiver = + payload_receiver_impl->_this (ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (payload_receiver.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + // If the ior_output_file exists, output the ior to it + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + + poa_manager->activate (ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_Time_Value tv (240, 0); + orb->run (tv, ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "Now terminating test\n")); + + root_poa->destroy (1, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/Big_Request_Muxing/server.dsp b/TAO/tests/Big_Request_Muxing/server.dsp new file mode 100644 index 00000000000..2225f1577e3 --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/server.dsp @@ -0,0 +1,216 @@ +# Microsoft Developer Studio Project File - Name="Big_Request_Muxing Server" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Big_Request_Muxing Server - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak" CFG="Big_Request_Muxing Server - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Big_Request_Muxing Server - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Big_Request_Muxing Server - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Big_Request_Muxing Server - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../../" /I "../../" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 TAO.lib TAO_PortableServer.lib ace.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ELSEIF "$(CFG)" == "Big_Request_Muxing Server - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "../../../" /I "../../" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 TAOd.lib TAO_PortableServerd.lib aced.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao\PortableServer" /libpath:"..\..\..\ace" /libpath:"..\..\tao"
+
+!ENDIF
+
+# Begin Target
+
+# Name "Big_Request_Muxing Server - Win32 Release"
+# Name "Big_Request_Muxing Server - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\Payload_Receiver.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ".h"
+# Begin Source File
+
+SOURCE=.\Payload_Receiver.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\Test.idl
+
+!IF "$(CFG)" == "Big_Request_Muxing Server - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__TEST_="..\..\..\bin\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\Release\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "Big_Request_Muxing Server - Win32 Debug"
+
+USERDEP__TEST_="..\..\..\bin\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\Test.idl
+InputName=Test
+
+BuildCmds= \
+ ..\..\..\bin\tao_idl -Ge 1 $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Inline Files"
+
+# PROP Default_Filter ".i"
+# Begin Source File
+
+SOURCE=.\TestC.i
+# End Source File
+# Begin Source File
+
+SOURCE=.\TestS.i
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/tests/Big_Request_Muxing/svc.conf b/TAO/tests/Big_Request_Muxing/svc.conf new file mode 100644 index 00000000000..9fb75aeb0dd --- /dev/null +++ b/TAO/tests/Big_Request_Muxing/svc.conf @@ -0,0 +1,4 @@ +# +# $Id$ +# +static Client_Strategy_Factory "-ORBTransportMuxStrategy MUXED" diff --git a/TAO/tests/Big_Twoways/Coordinator.cpp b/TAO/tests/Big_Twoways/Coordinator.cpp new file mode 100644 index 00000000000..52fa351d814 --- /dev/null +++ b/TAO/tests/Big_Twoways/Coordinator.cpp @@ -0,0 +1,83 @@ +// +// $Id$ +// +#include "Coordinator.h" + +ACE_RCSID(Big_Oneways, Coordinator, "$Id$") + +Coordinator::Coordinator (CORBA::ULong peer_count) + : peers_ (0) + , peer_count_ (0) + , peer_max_ (peer_count) +{ + ACE_NEW (this->peers_, Test::Peer_var[this->peer_max_]); +} + +Coordinator::~Coordinator (void) +{ + delete[] this->peers_; +} + +int +Coordinator::has_all_peers (void) const +{ + return this->peer_count_ == this->peer_max_; +} + +void +Coordinator::create_session_list (Test::Session_Control_ptr session_control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + Test::Session_List &session_list, + CORBA::Environment &ACE_TRY_ENV) +{ + session_list.length (this->peer_count_); + CORBA::ULong count = 0; + for (Test::Peer_var *i = this->peers_; + i != this->peers_ + this->peer_count_; + ++i) + { + session_list[count++] = + (*i)->create_session (session_control, + payload_size, + thread_count, + message_count, + this->peer_count_, + ACE_TRY_ENV); + ACE_CHECK; + } +} + +void +Coordinator::shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV) +{ + for (Test::Peer_var *i = this->peers_; + i != this->peers_ + this->peer_count_; + ++i) + { + ACE_TRY + { + (*i)->shutdown (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Coordinator::shutdown, ignored"); + } + ACE_ENDTRY; + } +} + +void +Coordinator::add_peer (Test::Peer_ptr peer, + CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + if (this->peer_count_ >= this->peer_max_) + return; + + this->peers_[this->peer_count_++] = + Test::Peer::_duplicate (peer); +} diff --git a/TAO/tests/Big_Twoways/Coordinator.h b/TAO/tests/Big_Twoways/Coordinator.h new file mode 100644 index 00000000000..e754658f952 --- /dev/null +++ b/TAO/tests/Big_Twoways/Coordinator.h @@ -0,0 +1,65 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_COORDINATOR_H +#define BIG_ONEWAYS_COORDINATOR_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Coordinator interface +class Coordinator + : public virtual POA_Test::Coordinator + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Coordinator (CORBA::ULong peer_count); + + /// Destructor + virtual ~Coordinator (void); + + /// Check if all the peers have registered already + int has_all_peers (void) const; + + /// Check a session on each peer + void create_session_list (Test::Session_Control_ptr session_control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + Test::Session_List &session_list, + CORBA::Environment &ACE_TRY_ENV); + + /// Shutdown all the peers + void shutdown_all_peers (CORBA::Environment &ACE_TRY_ENV); + + // = The skeleton methods + virtual void add_peer (Test::Peer_ptr peer, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Store a reference to each peer + Test::Peer_var *peers_; + + /// Current number of elements in the array + size_t peer_count_; + + /// Array's capacity + size_t peer_max_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_COORDINATOR_H */ diff --git a/TAO/tests/Big_Twoways/Makefile b/TAO/tests/Big_Twoways/Makefile new file mode 100644 index 00000000000..46b00dcc5c0 --- /dev/null +++ b/TAO/tests/Big_Twoways/Makefile @@ -0,0 +1,1700 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +LDLIBS = -lTAO + +IDL_FILES = Test +IDL_SRC = TestC.cpp TestS.cpp +BIN = server client + +SRC = $(addsuffix .cpp, $(BIN) Coordinator Peer Session Session_Control Session_Task) $(IDL_SRC) + +CLIENT_OBJS = client.o TestC.o TestS.o Peer.o Session.o Session_Task.o +SERVER_OBJS = server.o TestC.o TestS.o Coordinator.o Session_Control.o + +TAO_IDLFLAGS += -Ge 1 +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), Test$(ext)) + +server: $(addprefix $(VDIR),$(SERVER_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CLIENT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_SRVR_LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), Test$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp Coordinator.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i Session_Control.h \ + $(ACE_ROOT)/ace/Get_Opt.h + +.obj/client.o .obj/client.so .shobj/client.o .shobj/client.so: client.cpp Peer.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i + +.obj/Coordinator.o .obj/Coordinator.so .shobj/Coordinator.o .shobj/Coordinator.so: Coordinator.cpp Coordinator.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i + +.obj/Peer.o .obj/Peer.so .shobj/Peer.o .shobj/Peer.so: Peer.cpp Peer.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i Session.h Session_Task.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Task_T.i + +.obj/Session.o .obj/Session.so .shobj/Session.o .shobj/Session.so: Session.cpp Session.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i Session_Task.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(TAO_ROOT)/tao/debug.h + +.obj/Session_Control.o .obj/Session_Control.so .shobj/Session_Control.o .shobj/Session_Control.so: Session_Control.cpp Session_Control.h \ + $(ACE_ROOT)/ace/pre.h \ + TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i + +.obj/Session_Task.o .obj/Session_Task.so .shobj/Session_Task.o .shobj/Session_Task.so: Session_Task.cpp Session_Task.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Process_Mutex.h \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Task_T.i \ + Session.h TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i + +.obj/TestC.o .obj/TestC.so .shobj/TestC.o .shobj/TestC.so: TestC.cpp TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Synch_Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/Reply_Dispatcher.h \ + $(TAO_ROOT)/tao/TAOC.h \ + $(TAO_ROOT)/tao/Priority_Mapping_Manager.h \ + $(TAO_ROOT)/tao/Priority_Mapping.h \ + $(TAO_ROOT)/tao/operation_details.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/target_specification.h \ + $(TAO_ROOT)/tao/Invocation_Endpoint_Selectors.h \ + $(TAO_ROOT)/tao/ClientRequestInfo.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + TestC.i + +.obj/TestS.o .obj/TestS.so .shobj/TestS.o .shobj/TestS.so: TestS.cpp TestS.h TestC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(ACE_ROOT)/ace/pre.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Unbounded_Set.h \ + $(ACE_ROOT)/ace/Node.h \ + $(ACE_ROOT)/ace/Node.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.cpp \ + $(ACE_ROOT)/ace/Unbounded_Set.inl \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Exception.h \ + $(ACE_ROOT)/ace/SString.h \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(ACE_ROOT)/ace/CDR_Stream.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object_Proxy_Broker.h \ + $(TAO_ROOT)/tao/Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/NVList.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.h \ + $(ACE_ROOT)/ace/Unbounded_Queue.cpp \ + $(ACE_ROOT)/ace/Unbounded_Queue.inl \ + $(TAO_ROOT)/tao/LocalObject.h \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/OctetSeqC.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Managed_Types.h \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Services.h \ + $(TAO_ROOT)/tao/CORBA_String.h \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/Encodable.h \ + $(TAO_ROOT)/tao/Remote_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/BoundsC.h \ + $(TAO_ROOT)/tao/ValueBase.h \ + $(TAO_ROOT)/tao/ValueFactory.h \ + $(TAO_ROOT)/tao/DomainC.h \ + $(TAO_ROOT)/tao/WrongTransactionC.h \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/ObjectIDList.h \ + $(TAO_ROOT)/tao/PortableInterceptor.h \ + $(TAO_ROOT)/tao/PortableInterceptorC.h \ + $(TAO_ROOT)/tao/DynamicC.h \ + $(TAO_ROOT)/tao/MessagingC.h \ + $(TAO_ROOT)/tao/TimeBaseC.h \ + $(TAO_ROOT)/tao/SmartProxies/Smart_Proxies.h \ + $(TAO_ROOT)/tao/SmartProxies/smartproxies_export.h \ + $(TAO_ROOT)/tao/TAO_Singleton.h \ + $(TAO_ROOT)/tao/TAO_Singleton.cpp \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(TAO_ROOT)/tao/TAO_Singleton_Manager.h \ + $(TAO_ROOT)/tao/TAO_Singleton.inl \ + $(TAO_ROOT)/tao/IOPC.h \ + $(TAO_ROOT)/tao/PollableC.h \ + $(TAO_ROOT)/tao/Interceptor_List.h \ + $(ACE_ROOT)/ace/Array_Base.h \ + $(ACE_ROOT)/ace/Array_Base.cpp \ + $(ACE_ROOT)/ace/Array_Base.inl \ + $(TAO_ROOT)/tao/StringSeqC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServer.h \ + $(TAO_ROOT)/tao/PortableServer/portableserver_export.h \ + $(TAO_ROOT)/tao/PortableServer/RTPortableServerC.h \ + $(TAO_ROOT)/tao/PortableServer/PortableServerC.h \ + $(TAO_ROOT)/tao/RTCORBAC.h \ + $(TAO_ROOT)/tao/PortableServer/Servant_Base.h \ + $(TAO_ROOT)/tao/Abstract_Servant_Base.h \ + $(TAO_ROOT)/tao/PortableServer/Collocated_Object.h \ + $(TAO_ROOT)/tao/PortableServer/ThruPOA_Object_Proxy_Impl.h \ + $(TAO_ROOT)/tao/PortableServer/Direct_Object_Proxy_Impl.h \ + TestS_T.h TestS_T.cpp TestS_T.i \ + $(TAO_ROOT)/tao/PortableServer/Object_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/Key_Adapters.h \ + $(ACE_ROOT)/ace/Map.h \ + $(ACE_ROOT)/ace/Map_T.h \ + $(ACE_ROOT)/ace/Pair.h \ + $(ACE_ROOT)/ace/Pair_T.h \ + $(ACE_ROOT)/ace/Pair_T.cpp \ + $(ACE_ROOT)/ace/Pair_T.i \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Test_and_Set.h \ + $(ACE_ROOT)/ace/Test_and_Set.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Functor.h \ + $(ACE_ROOT)/ace/Functor_T.h \ + $(ACE_ROOT)/ace/Functor_T.cpp \ + $(ACE_ROOT)/ace/Functor_T.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Active_Map_Manager.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.h \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.cpp \ + $(ACE_ROOT)/ace/Active_Map_Manager_T.i \ + $(ACE_ROOT)/ace/Map_T.cpp \ + $(ACE_ROOT)/ace/Map_T.i \ + $(TAO_ROOT)/tao/PortableServer/poa_macros.h \ + $(TAO_ROOT)/tao/PortableServer/Active_Object_Map.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Adapter.h \ + $(TAO_ROOT)/tao/Service_Context.h \ + $(TAO_ROOT)/tao/PortableServer/Operation_Table.h \ + $(TAO_ROOT)/tao/TAO_Server_Request.h \ + $(TAO_ROOT)/tao/Tagged_Profile.h \ + $(TAO_ROOT)/tao/GIOPC.h \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/Policy_Manager.h \ + $(TAO_ROOT)/tao/Resource_Factory.h \ + $(TAO_ROOT)/tao/Pluggable.h \ + $(TAO_ROOT)/tao/Protocol_Factory.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/PolicyFactory_Registry.h \ + $(TAO_ROOT)/tao/Parser_Registry.h \ + $(TAO_ROOT)/tao/Service_Callbacks.h \ + $(TAO_ROOT)/tao/Fault_Tolerance_Service.h \ + $(TAO_ROOT)/tao/Transport_Cache_Manager.h \ + $(TAO_ROOT)/tao/Cache_Entries.h \ + $(TAO_ROOT)/tao/Transport_Descriptor_Interface.h \ + $(TAO_ROOT)/tao/Endpoint.h \ + $(TAO_ROOT)/tao/Cleanup_Func_Registry.h \ + $(TAO_ROOT)/tao/Object_Ref_Table.h \ + $(TAO_ROOT)/tao/RT_Policy_i.h \ + $(TAO_ROOT)/tao/Protocols_Hooks.h \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Singleton.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/MProfile.h \ + $(TAO_ROOT)/tao/Profile.h \ + $(TAO_ROOT)/tao/Tagged_Components.h \ + $(TAO_ROOT)/tao/CONV_FRAMEC.h \ + $(TAO_ROOT)/tao/GIOP_Message_State.h \ + $(TAO_ROOT)/tao/IFR_Client_Adapter.h \ + $(TAO_ROOT)/tao/PortableServer/ServerRequestInfo.h \ + $(TAO_ROOT)/tao/RequestInfo_Util.h \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service_Base.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(ACE_ROOT)/ace/Dynamic_Service.i \ + TestS.i + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/tests/Big_Twoways/Peer.cpp b/TAO/tests/Big_Twoways/Peer.cpp new file mode 100644 index 00000000000..e5cf894acba --- /dev/null +++ b/TAO/tests/Big_Twoways/Peer.cpp @@ -0,0 +1,51 @@ +// +// $Id$ +// +#include "Peer.h" +#include "Session.h" + +ACE_RCSID(Big_Oneways, Peer, "$Id$") + +Peer::Peer (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +Peer::~Peer (void) +{ +} + +Test::Session_ptr +Peer::create_session (Test::Session_Control_ptr control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + CORBA::ULong peer_count, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + Session *session_impl; + ACE_NEW_THROW_EX (session_impl, + Session (control, + payload_size, + thread_count, + message_count, + peer_count), + CORBA::NO_MEMORY ()); + ACE_CHECK_RETURN (Test::Session::_nil ()); + PortableServer::ServantBase_var transfer_ownership (session_impl); + + return session_impl->_this (ACE_TRY_ENV); +} + +void +Peer::shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Peer::shutdown, waiting for threads\n")); + + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Peer::shutdown, shutting down ORB\n")); + this->orb_->shutdown (0, ACE_TRY_ENV); +} diff --git a/TAO/tests/Big_Twoways/Peer.h b/TAO/tests/Big_Twoways/Peer.h new file mode 100644 index 00000000000..ed34b0eb6fa --- /dev/null +++ b/TAO/tests/Big_Twoways/Peer.h @@ -0,0 +1,51 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_PEER_H +#define BIG_ONEWAYS_PEER_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Peer interface +class Peer + : public virtual POA_Test::Peer + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Peer (CORBA::ORB_ptr orb); + + /// Destructor + virtual ~Peer (void); + + // = The skeleton methods + virtual Test::Session_ptr create_session (Test::Session_Control_ptr control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + CORBA::ULong peer_count, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual void shutdown (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Keep a pointer to the ORB to shutdown cleanly + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_PEER_H */ diff --git a/TAO/tests/Big_Twoways/README b/TAO/tests/Big_Twoways/README new file mode 100644 index 00000000000..ed389e9009c --- /dev/null +++ b/TAO/tests/Big_Twoways/README @@ -0,0 +1,21 @@ +/** + +@page Big_Oneways Test README File + + This is a stress test for the non-blocking I/O features in the +ORB. The test connects multiple peer processes together. Each +process sends messages to all its peers, using multiple threads to +generate the messages. Without non-blocking I/O the system soon +deadlocks. + + This is part of the regression testsuite for: + +http://ace.cs.wustl.edu/bugzilla/show_bug.cgi?id=132 + + To run the test use the run_test.pl script: + +$ ./run_test.pl + + the script returns 0 if the test was successful. + +*/ diff --git a/TAO/tests/Big_Twoways/Session.cpp b/TAO/tests/Big_Twoways/Session.cpp new file mode 100644 index 00000000000..de4153c50e0 --- /dev/null +++ b/TAO/tests/Big_Twoways/Session.cpp @@ -0,0 +1,250 @@ +// +// $Id$ +// +#include "Session.h" +#include "tao/debug.h" + +ACE_RCSID(Big_Oneways, Session, "$Id$") + +Session::Session (Test::Session_Control_ptr control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + CORBA::ULong peer_count) + : control_ (Test::Session_Control::_duplicate (control)) + , running_ (0) + , payload_size_ (payload_size) + , thread_count_ (thread_count) + , message_count_ (message_count) + , active_thread_count_ (0) + , expected_messages_ (thread_count * message_count * (peer_count - 1)) + , task_ (this) + , barrier_ (thread_count + 1) +{ +} + +Session::~Session (void) +{ +} + +int +Session::svc (void) +{ + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::svc, start\n")); + + this->barrier_.wait (); + + /// Automatically decrease the reference count at the end of the + /// thread + PortableServer::ServantBase_var auto_decrement (this); + + ACE_DECLARE_NEW_CORBA_ENV; + + ACE_TRY + { + // Use the same payload over and over + Test::Payload payload (this->payload_size_); + payload.length (this->payload_size_); + + // Get the number of peers just once. + CORBA::ULong session_count = + this->other_sessions_.length (); + + for (CORBA::ULong i = 0; i != this->message_count_; ++i) + { +#if 0 + if (i % 500 == 0) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::svc, " + "sending message %d\n", + i)); + } +#endif /* 0 */ + for (CORBA::ULong j = 0; j != session_count; ++j) + { + Test::Payload_var received = + this->other_sessions_[j]->echo_payload (payload, + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + } + + { + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, -1); + this->active_thread_count_--; + if (this->more_work ()) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::svc, end\n")); + return 0; + } + } + this->terminate (1, ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Session::svc - "); + return -1; + } + ACE_ENDTRY; + + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::svc, end\n")); + return 0; +} + +void +Session::start (const Test::Session_List &other_sessions, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException, + Test::Already_Running, + Test::No_Peers)) +{ + if (other_sessions.length () == 0) + ACE_THROW (Test::No_Peers ()); + + { + ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); + if (this->running_) + ACE_THROW (Test::Already_Running ()); + + this->other_sessions_ = other_sessions; + + for (CORBA::ULong i = 0; i != this->thread_count_; ++i) + { + // Increase the reference count because the new thread will have + // access to this object.... + ACE_TRY + { + this->_add_ref (ACE_TRY_ENV); + ACE_TRY_CHECK; + if (this->task_.activate ( + THR_NEW_LWP | THR_JOINABLE, 1, 1) == -1) + { + this->_remove_ref (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + else + { + this->running_ = 1; + this->active_thread_count_++; + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Session::start, ignored"); + } + ACE_ENDTRY; + } + + if (this->active_thread_count_ != this->thread_count_) + return; + + this->barrier_.wait (); + + if (this->running_ != 0) + return; + } + /// None of the threads are running, this session is useless at + /// this point, report the problem and destroy the local objects + this->terminate (0, ACE_TRY_ENV); +} + +Test::Payload * +Session::echo_payload (const Test::Payload &the_payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + if (the_payload.length () != this->payload_size_) + { + ACE_ERROR ((LM_ERROR, + "ERROR: (%P|%t) Session::echo_payload, " + "unexpected payload size (%d != %d)\n", + the_payload.length (), this->payload_size_)); + } + + Test::Payload_var retval (new Test::Payload (the_payload)); + + { + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, + retval._retn ()); + this->expected_messages_--; + + int verbose = 0; +#if 0 + verbose = this->expected_messages_ % 500 == 0; + if (this->expected_messages_ < 500) + verbose = (this->expected_messages_ % 100 == 0); + if (this->expected_messages_ < 100) + verbose = (this->expected_messages_ % 10 == 0); +#endif /* 0 */ + if (this->expected_messages_ < 5) + verbose = 1; + + if (verbose) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session::echo_payload, " + "%d messages to go\n", + this->expected_messages_)); + } + if (this->more_work ()) + return retval._retn (); + } + this->terminate (1, ACE_TRY_ENV); + + return retval._retn (); +} + + +void +Session::destroy (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Make sure local resources are released + + PortableServer::POA_var poa = + this->_default_POA (ACE_TRY_ENV); + ACE_CHECK; + PortableServer::ObjectId_var oid = + poa->servant_to_id (this, ACE_TRY_ENV); + ACE_CHECK; + poa->deactivate_object (oid.in (), ACE_TRY_ENV); + ACE_CHECK; +} + +int +Session::more_work (void) const +{ + if (this->expected_messages_ > 0 + || this->active_thread_count_ > 0 + || this->running_ == 0) + return 1; + + return 0; +} + +void +Session::terminate (CORBA::Boolean success, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC (()) +{ + // Make sure that global resources are released + ACE_TRY_EX(GLOBAL) + { + this->control_->session_finished (success, + ACE_TRY_ENV); + ACE_TRY_CHECK_EX(GLOBAL); + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Session::terminate, ignored"); + } + ACE_ENDTRY; + +} diff --git a/TAO/tests/Big_Twoways/Session.h b/TAO/tests/Big_Twoways/Session.h new file mode 100644 index 00000000000..1caf5a37506 --- /dev/null +++ b/TAO/tests/Big_Twoways/Session.h @@ -0,0 +1,104 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_SESSION_H +#define BIG_ONEWAYS_SESSION_H +#include "ace/pre.h" + +#include "TestS.h" +#include "Session_Task.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Session interface +class Session + : public virtual POA_Test::Session + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Session (Test::Session_Control_ptr control, + CORBA::ULong payload_size, + CORBA::ULong thread_count, + CORBA::ULong message_count, + CORBA::ULong peer_count); + + /// Destructor + virtual ~Session (void); + + /// Run one of the experiment threads + int svc (void); + + // = The skeleton methods + virtual void start (const Test::Session_List &other_sessions, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException, + Test::Already_Running, + Test::No_Peers)); + + virtual Test::Payload* echo_payload (const Test::Payload &the_payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void destroy (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Helper function used to report any problems and destroy local + /// resources + void terminate (CORBA::Boolean success, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC (()); + + /// Return 1 if all the work in this session has been completed + int more_work (void) const; + +private: + /// Synchronize the internal state + ACE_SYNCH_MUTEX mutex_; + + /// Keep a reference to the Session_Control, this is used to report + /// when the test finishes. + Test::Session_Control_var control_; + + /// Keep track of wether the test is running. + int running_; + + /// The other session objects participating in the test + Test::Session_List other_sessions_; + + /// Size of each message + CORBA::ULong payload_size_; + + /// Number of threads + CORBA::ULong thread_count_; + + /// Number of messages to send + CORBA::ULong message_count_; + + /// The number of threads currently running, when this reaches 0 the + /// session destroys itself. + CORBA::ULong active_thread_count_; + + /// Number of messages expected + CORBA::ULong expected_messages_; + + /// Helper class to run svc() in a separate thread + Session_Task task_; + + /// Barrier to start all threads simultaenously + ACE_Thread_Barrier barrier_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_SESSION_H */ diff --git a/TAO/tests/Big_Twoways/Session_Control.cpp b/TAO/tests/Big_Twoways/Session_Control.cpp new file mode 100644 index 00000000000..f0f5c3bd4b4 --- /dev/null +++ b/TAO/tests/Big_Twoways/Session_Control.cpp @@ -0,0 +1,75 @@ +// +// $Id$ +// +#include "Session_Control.h" + +ACE_RCSID(Big_Oneways, Session_Control, "$Id$") + +Session_Control::Session_Control (CORBA::ULong session_count) + : session_count_ (session_count) + , success_ (1) +{ +} + +int +Session_Control::all_sessions_finished (void) const +{ + return this->session_count_ == 0; +} + +Session_Control::~Session_Control (void) +{ + if (this->session_count_ == 0 && this->success_) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session_Control::~Session_control, " + " good, all sessions did finish\n")); + } + else if (session_count_ != 0) + { + ACE_ERROR ((LM_ERROR, + "ERROR: (%P|%t) Session_Control::~Session_control, " + " %d sessions did not finish\n", + this->session_count_)); + } + else + { + ACE_ERROR ((LM_ERROR, + "ERROR: (%P|%t) Session_Control::~Session_control, " + " some sessions failed\n")); + } +} + +void +Session_Control::session_finished (CORBA::Boolean success, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); + if (this->session_count_ == 0) + { + ACE_ERROR ((LM_ERROR, + "ERROR: (%P|%t) Session_Control::session_finished, " + "unexpected callback\n")); + } + if (success == 0) + this->success_ = 0; + + this->session_count_--; + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Session_Control::session_finished, " + "%d sessions to go\n", + this->session_count_)); + if (session_count_ == 0) + { + PortableServer::POA_var poa = + this->_default_POA (ACE_TRY_ENV); + ACE_CHECK; + PortableServer::ObjectId_var oid = + poa->servant_to_id (this, ACE_TRY_ENV); + ACE_CHECK; + poa->deactivate_object (oid.in (), ACE_TRY_ENV); + ACE_CHECK; + } + +} diff --git a/TAO/tests/Big_Twoways/Session_Control.h b/TAO/tests/Big_Twoways/Session_Control.h new file mode 100644 index 00000000000..09c19dbaaba --- /dev/null +++ b/TAO/tests/Big_Twoways/Session_Control.h @@ -0,0 +1,57 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_SESSION_CONTROL_H +#define BIG_ONEWAYS_SESSION_CONTROL_H +#include "ace/pre.h" + +#include "TestS.h" + +#if defined (_MSC_VER) +# if (_MSC_VER >= 1200) +# pragma warning(push) +# endif /* _MSC_VER >= 1200 */ +# pragma warning (disable:4250) +#endif /* _MSC_VER */ + +/// Implement the Test::Session_Control interface +class Session_Control + : public virtual POA_Test::Session_Control + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + /** + * @param session_count Number of session objects in the experiment. + */ + Session_Control (CORBA::ULong session_count); + + /// Destructor + virtual ~Session_Control (void); + + /// Return 1 when all sessions have finished + int all_sessions_finished (void) const; + + // = The skeleton methods + virtual void session_finished (CORBA::Boolean success, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Synchronize the internal state + ACE_SYNCH_MUTEX mutex_; + + /// The type of test + CORBA::ULong session_count_; + + /// Set to falso if any session reported a failure + CORBA::Boolean success_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_SESSION_CONTROL_H */ diff --git a/TAO/tests/Big_Twoways/Session_Task.cpp b/TAO/tests/Big_Twoways/Session_Task.cpp new file mode 100644 index 00000000000..bd992a66e5d --- /dev/null +++ b/TAO/tests/Big_Twoways/Session_Task.cpp @@ -0,0 +1,19 @@ +// +// $Id$ +// + +#include "Session_Task.h" +#include "Session.h" + +ACE_RCSID(Big_Oneways, Session_Task, "$Id$") + +Session_Task::Session_Task (Session *session) + : session_ (session) +{ +} + +int +Session_Task::svc (void) +{ + return this->session_->svc (); +} diff --git a/TAO/tests/Big_Twoways/Session_Task.h b/TAO/tests/Big_Twoways/Session_Task.h new file mode 100644 index 00000000000..2ef3bf69925 --- /dev/null +++ b/TAO/tests/Big_Twoways/Session_Task.h @@ -0,0 +1,33 @@ +// +// $Id$ +// + +#ifndef BIG_ONEWAYS_SESSION_TASK_H +#define BIG_ONEWAYS_SESSION_TASK_H +#include "ace/pre.h" + +#include "ace/Task.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class Session; + +/// Implement a Task to run the experiments using multiple threads. +class Session_Task : public ACE_Task_Base +{ +public: + /// Constructor + Session_Task (Session *session); + + /// Thread entry point + int svc (void); + +private: + /// Reference to the test interface + Session *session_; +}; + +#include "ace/post.h" +#endif /* BIG_ONEWAYS_SESSION_TASK_H */ diff --git a/TAO/tests/Big_Twoways/Test.idl b/TAO/tests/Big_Twoways/Test.idl new file mode 100644 index 00000000000..04255aa1262 --- /dev/null +++ b/TAO/tests/Big_Twoways/Test.idl @@ -0,0 +1,80 @@ +// +// $Id$ +// + +module Test +{ + /// The message type, just used to send a lot of data on each + /// request + typedef sequence<octet> Payload; + + /// A session is a single instance of the test + interface Session; + typedef sequence<Session> Session_List; + + /// A session control is used to determine if all the Session in an + /// experiment have finished. + /** + * @param success If false then the session failed, the experiment + * is successful only if all sessions finish successfully + */ + interface Session_Control + { + void session_finished (in boolean success); + }; + + /// A Peer is used to create sessions + interface Peer + { + /// Create a new session + /** + * @param payload_size The size of each message + * @param thread_count The number of threads that each session + * must create + * @param message_count How many messages does each thread send. + */ + Session create_session (in Session_Control control, + in unsigned long payload_size, + in unsigned long thread_count, + in unsigned long message_count, + in unsigned long peer_count); + + /// Shutdown the peer + oneway void shutdown (); + }; + + /// The Session already has an experiment running. + exception Already_Running {}; + + /// The experiment requires at least two Sessions + exception No_Peers {}; + + interface Session + { + /// Start the test, send messages to all the peers + /** + * @param other_sessions The list of sessions participating in the + * experiment, this list must not include the session + * receiving the start() call. + */ + void start (in Session_List other_sessions) + raises (Already_Running, No_Peers); + + /// Echo back the payload + Payload echo_payload (in Payload the_payload); + + /// Destroy the Session object + void destroy (); + }; + + interface Coordinator + { + /// Add a new peer. + /** + * The coordinator starts the test by calling <send_oneways> on + * all peers. How does it decide to do that is application + * specific. + */ + void add_peer (in Peer the_peer); + }; +}; diff --git a/TAO/tests/Big_Twoways/client.cpp b/TAO/tests/Big_Twoways/client.cpp new file mode 100644 index 00000000000..542c9ed70ed --- /dev/null +++ b/TAO/tests/Big_Twoways/client.cpp @@ -0,0 +1,116 @@ +// $Id$ + +#include "Peer.h" +#include "ace/Get_Opt.h" +#include "ace/Thread_Manager.h" + +ACE_RCSID(Big_Oneways, client, "$Id$") + +const char *ior = "file://test.ior"; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "k:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'k': + ior = get_opts.optarg; + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + ACE_TRY_CHECK; + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (poa_object.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Panic got a nil RootPOA\n"), + 1); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var tmp = + orb->string_to_object(ior, ACE_TRY_ENV); + ACE_TRY_CHECK; + + Test::Coordinator_var coordinator = + Test::Coordinator::_narrow(tmp.in (), ACE_TRY_ENV); + if (CORBA::is_nil (coordinator.in ())) + { + ACE_ERROR_RETURN ((LM_DEBUG, + "Nil coordinator reference <%s>\n", + ior), + 1); + } + + Peer *peer_impl; + ACE_NEW_RETURN (peer_impl, + Peer (orb.in ()), + 1); + PortableServer::ServantBase_var peer_owner_transfer(peer_impl); + + Test::Peer_var peer = + peer_impl->_this (ACE_TRY_ENV); + + poa_manager->activate (ACE_TRY_ENV); + ACE_TRY_CHECK; + + coordinator->add_peer (peer.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->run (ACE_TRY_ENV); + ACE_TRY_CHECK; + + // Wait for all the threads. + ACE_Thread_Manager::instance ()->wait (); + + root_poa->destroy (1, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/Big_Twoways/run_test.pl b/TAO/tests/Big_Twoways/run_test.pl new file mode 100755 index 00000000000..7cbfa22085d --- /dev/null +++ b/TAO/tests/Big_Twoways/run_test.pl @@ -0,0 +1,86 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; +use Getopt::Std; + +local ($opt_i, $opt_b); + +if (!getopts ('i:b:')) { + print "Usage: run_test.pl [-b payload_size] [-i iterations]\n"; + exit 1; +} + +my $server_args = " -p 4"; +if (defined $opt_i) { + $server_args .= " -i ".$opt_i; +} +if (defined $opt_b) { + $server_args .= " -b ".$opt_b; +} + +$iorfile = PerlACE::LocalFile ("server.ior"); + +unlink $iorfile; +$SV = new PerlACE::Process ("server", "-o $iorfile $server_args"); +$CL1 = new PerlACE::Process ("client", " -k file://$iorfile"); +$CL2 = new PerlACE::Process ("client", " -k file://$iorfile"); +$CL3 = new PerlACE::Process ("client", " -k file://$iorfile"); +$CL4 = new PerlACE::Process ("client", " -k file://$iorfile"); + +$SV->Spawn (); + +if (PerlACE::waitforfile_timed ($iorfile, 15) == -1) { + print STDERR "ERROR: cannot find file <$iorfile>\n"; + $SV->Kill (); $SV->TimedWait (1); + exit 1; +} + +$CL1->Spawn (); +$CL2->Spawn (); +$CL3->Spawn (); +$CL4->Spawn (); + +$client1 = $CL1->WaitKill (300); + +if ($client1 != 0) { + print STDERR "ERROR: client 1 returned $client1\n"; + $status = 1; +} + +$client2 = $CL2->WaitKill (300); + +if ($client2 != 0) { + print STDERR "ERROR: client 2 returned $client2\n"; + $status = 1; +} + +$client3 = $CL3->WaitKill (300); + +if ($client3 != 0) { + print STDERR "ERROR: client 3 returned $client3\n"; + $status = 1; +} + +$client4 = $CL4->WaitKill (300); + +if ($client4 != 0) { + print STDERR "ERROR: client 4 returned $client3\n"; + $status = 1; +} + +$server = $SV->TerminateWaitKill (5); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; +} + +unlink $iorfile; + +exit $status; diff --git a/TAO/tests/Big_Twoways/server.cpp b/TAO/tests/Big_Twoways/server.cpp new file mode 100644 index 00000000000..becf7ab3861 --- /dev/null +++ b/TAO/tests/Big_Twoways/server.cpp @@ -0,0 +1,218 @@ +// $Id$ + +#include "Coordinator.h" +#include "Session_Control.h" +#include "ace/Get_Opt.h" + +ACE_RCSID(Big_Oneways, server, "$Id$") + +const char *ior_output_file = "test.ior"; +CORBA::ULong peer_count = 4; +CORBA::ULong payload_size = 1024; +CORBA::ULong message_count = 1000; +CORBA::ULong thread_count = 4; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "o:p:b:i:n:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + ior_output_file = get_opts.optarg; + break; + + case 'p': + peer_count = ACE_OS::atoi (get_opts.optarg); + break; + + case 'b': + payload_size = ACE_OS::atoi (get_opts.optarg); + break; + + case 'i': + message_count = ACE_OS::atoi (get_opts.optarg); + break; + + case 'n': + thread_count = ACE_OS::atoi (get_opts.optarg); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-o <iorfile> " + "-p <peer_count> " + "-b <payload_size> " + "-i <message_count> " + "-n <thread_count> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "", ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA", ACE_TRY_ENV); + ACE_TRY_CHECK; + + PortableServer::POA_var root_poa = + PortableServer::POA::_narrow (poa_object.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (CORBA::is_nil (poa_object.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Panic got a nil RootPOA\n"), + 1); + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Coordinator *coordinator_impl; + ACE_NEW_RETURN (coordinator_impl, + Coordinator (peer_count), + 1); + PortableServer::ServantBase_var coordinator_owner_transfer(coordinator_impl); + + Test::Coordinator_var coordinator = + coordinator_impl->_this (ACE_TRY_ENV); + + CORBA::String_var ior = + orb->object_to_string (coordinator.in (), ACE_TRY_ENV); + ACE_TRY_CHECK; + + // If the ior_output_file exists, output the ior to it + FILE *output_file= ACE_OS::fopen (ior_output_file, "w"); + if (output_file == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot open output file for writing IOR: %s", + ior_output_file), + 1); + ACE_OS::fprintf (output_file, "%s", ior.in ()); + ACE_OS::fclose (output_file); + + poa_manager->activate (ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "Waiting for peers . . . ")); + for (int i = 0; + i != 30 && !coordinator_impl->has_all_peers (); + ++i) + { + ACE_Time_Value tv (1, 0); + orb->run (tv, ACE_TRY_ENV); + } + ACE_DEBUG ((LM_DEBUG, "done.\n")); + + if (!coordinator_impl->has_all_peers ()) + { + ACE_ERROR ((LM_DEBUG, + "ERROR: timeout, some peers failed to register\n")); + return 1; + } + + Session_Control *session_control_impl; + ACE_NEW_RETURN (session_control_impl, + Session_Control (peer_count), + 1); + PortableServer::ServantBase_var session_control_owner_transfer(session_control_impl); + + Test::Session_Control_var session_control = + session_control_impl->_this (ACE_TRY_ENV); + + Test::Session_List session_list; + coordinator_impl->create_session_list (session_control.in (), + payload_size, + thread_count, + message_count, + session_list, + ACE_TRY_ENV); + ACE_TRY_CHECK; + + ACE_ASSERT (session_list.length () == peer_count); + + CORBA::ULong j; + for (j = 0; j != peer_count; ++j) + { + // Make a copy of the sessions, excluding the j-th element + Test::Session_List other_sessions (peer_count - 1); + other_sessions.length (peer_count - 1); + CORBA::ULong count = 0; + for (CORBA::ULong k = 0; k != peer_count; ++k) + { + if (k == j) + continue; + other_sessions[count++] = + Test::Session::_duplicate (session_list[k]); + } + + session_list[j]->start (other_sessions, + ACE_TRY_ENV); + ACE_TRY_CHECK; + + } + + ACE_DEBUG ((LM_DEBUG, "Waiting for sessions . . . \n")); + for (int k = 0; + k != 300 && !session_control_impl->all_sessions_finished (); + ++k) + { + ACE_Time_Value tv (1, 0); + orb->run (tv, ACE_TRY_ENV); + ACE_TRY_CHECK; + } + + if (!session_control_impl->all_sessions_finished ()) + { + ACE_ERROR ((LM_ERROR, + "ERROR: timeout waiting for sessions\n")); + return 1; + } + + ACE_DEBUG ((LM_DEBUG, "All sessions finished . . . \n")); + + for (j = 0; j != peer_count; ++j) + { + session_list[j]->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + + } + + coordinator_impl->shutdown_all_peers (ACE_TRY_ENV); + ACE_TRY_CHECK; + + root_poa->destroy (1, 1, ACE_TRY_ENV); + ACE_TRY_CHECK; + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/tests/Blocking_Sync_None/Test.idl b/TAO/tests/Blocking_Sync_None/Test.idl index 5e8a1360b7e..46596465827 100644 --- a/TAO/tests/Blocking_Sync_None/Test.idl +++ b/TAO/tests/Blocking_Sync_None/Test.idl @@ -21,6 +21,6 @@ module Test in unsigned long sleep_microseconds); /// Shutdown the server - oneway void shutdown (); + void shutdown (); }; }; diff --git a/TAO/tests/LongWrites/Coordinator.cpp b/TAO/tests/LongWrites/Coordinator.cpp index 8520ae19963..d9e382e42d0 100644 --- a/TAO/tests/LongWrites/Coordinator.cpp +++ b/TAO/tests/LongWrites/Coordinator.cpp @@ -5,8 +5,11 @@ ACE_RCSID(LongWrites, Coordinator, "$Id$") -Coordinator::Coordinator (void) - : shutdown_called_ (0) +Coordinator::Coordinator (CORBA::ULong initial_payload_size, + CORBA::Long test_iterations) + : initial_payload_size_ (initial_payload_size) + , test_iterations_ (test_iterations) + , shutdown_called_ (0) , pairs_count_ (0) , pairs_length_ (16) { @@ -59,12 +62,13 @@ Coordinator::start (CORBA::Environment &ACE_TRY_ENV) } } - CORBA::ULong event_size = 256 * 1024; + CORBA::ULong event_size = this->initial_payload_size_; ACE_DEBUG ((LM_DEBUG, "Running with payload = %d\n", event_size)); for (size_t j = 0; j != this->pairs_count_; ++j) { - this->pairs_[j].sender->send_events (100, event_size, + this->pairs_[j].sender->send_events (this->test_iterations_, + event_size, ACE_TRY_ENV); ACE_CHECK; } diff --git a/TAO/tests/LongWrites/Coordinator.h b/TAO/tests/LongWrites/Coordinator.h index db00336489a..9fe37a8e699 100644 --- a/TAO/tests/LongWrites/Coordinator.h +++ b/TAO/tests/LongWrites/Coordinator.h @@ -22,7 +22,8 @@ class Coordinator { public: /// Constructor - Coordinator (void); + Coordinator (CORBA::ULong initial_payload_size, + CORBA::Long test_iterations); /// Destructor virtual ~Coordinator (void); @@ -46,13 +47,27 @@ public: }; private: + /// Initial payload size + CORBA::ULong initial_payload_size_; + + /// Number of iterations performed by each server. + CORBA::Long test_iterations_; + + /// Synchronize internal data structure ACE_SYNCH_MUTEX mutex_; + /// Set to 1 once the test has shutdown int shutdown_called_; + /** @name List of pairs + * + * Implement a simple list of pairs + */ + //@{ size_t pairs_count_; size_t pairs_length_; Pair* pairs_; + //@} }; #if defined(_MSC_VER) && (_MSC_VER >= 1200) diff --git a/TAO/tests/LongWrites/Makefile b/TAO/tests/LongWrites/Makefile index 07e5024de83..011d622d2c3 100644 --- a/TAO/tests/LongWrites/Makefile +++ b/TAO/tests/LongWrites/Makefile @@ -18,9 +18,9 @@ IDL_FILES = Test IDL_SRC = TestC.cpp TestS.cpp BIN = server client -SRC = $(addsuffix .cpp, $(BIN) Receiver Sender Coordinator) $(IDL_SRC) +SRC = $(addsuffix .cpp, $(BIN) Receiver Sender Sender_Task Coordinator) $(IDL_SRC) -CLIENT_OBJS = client.o TestC.o TestS.o Receiver.o Sender.o +CLIENT_OBJS = client.o TestC.o TestS.o Receiver.o Sender.o Sender_Task.o SERVER_OBJS = server.o TestC.o TestS.o Coordinator.o TAO_IDLFLAGS += -Ge 1 diff --git a/TAO/tests/LongWrites/Receiver.cpp b/TAO/tests/LongWrites/Receiver.cpp index 6425de4a18a..7d7f23ea44c 100644 --- a/TAO/tests/LongWrites/Receiver.cpp +++ b/TAO/tests/LongWrites/Receiver.cpp @@ -11,6 +11,13 @@ Receiver::Receiver (void) { } +CORBA::ULong +Receiver::message_count (void) +{ + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, 0); + return this->message_count_; +} + void Receiver::dump_results () { @@ -31,5 +38,25 @@ Receiver::receive_data (const Test::Payload &payload, this->message_count_++; this->byte_count_ += payload.length (); - ACE_DEBUG ((LM_DEBUG, "Receiver::receive_data\n")); + if (this->message_count_ % 100 == 0) + { + ACE_DEBUG ((LM_DEBUG, "(%P|%t) Receiver::receive_data %d\n", + this->message_count_)); + } +} + +void +Receiver::receive_data_oneway (const Test::Payload &payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->receive_data (payload, ACE_TRY_ENV); +} + +Test::Payload * +Receiver::return_data (const Test::Payload &payload, + CORBA::Environment &) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return new Test::Payload (payload); } diff --git a/TAO/tests/LongWrites/Receiver.h b/TAO/tests/LongWrites/Receiver.h index 5242259d81f..8a0b50d1d05 100644 --- a/TAO/tests/LongWrites/Receiver.h +++ b/TAO/tests/LongWrites/Receiver.h @@ -27,6 +27,9 @@ public: /// Constructor Receiver (void); + /// Return the number of messages received so far + CORBA::ULong message_count (void); + /// Print out the results void dump_results (void); @@ -34,6 +37,12 @@ public: virtual void receive_data (const Test::Payload &payload, CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)); + virtual void receive_data_oneway (const Test::Payload &payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual Test::Payload *return_data (const Test::Payload &payload, + CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)); private: ACE_SYNCH_MUTEX mutex_; diff --git a/TAO/tests/LongWrites/Sender.cpp b/TAO/tests/LongWrites/Sender.cpp index 3d7926feb3b..e3dab2ee42b 100644 --- a/TAO/tests/LongWrites/Sender.cpp +++ b/TAO/tests/LongWrites/Sender.cpp @@ -5,10 +5,13 @@ ACE_RCSID(LongWrites, Sender, "$Id$") -Sender::Sender (void) - : receiver_count_ (0) +Sender::Sender (int test_type) + : test_type_ (test_type) + , receiver_count_ (0) , receiver_length_ (16) , shutdown_called_ (0) + , event_count_ (0) + , sender_task_ (this) { ACE_NEW (this->receivers_, Test::Receiver_var[this->receiver_length_]); } @@ -18,6 +21,17 @@ Sender::~Sender (void) delete[] this->receivers_; } +int +Sender::test_done (CORBA::ULong message_count) +{ + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->mutex_, 0); + return + (this->event_count_ != 0 + && this->receiver_count_ != 0 + && this->shutdown_called_ != 0 + && (4 * this->receiver_count_ + * this->event_count_ <= message_count)); +} int Sender::shutdown_called (void) @@ -28,9 +42,10 @@ Sender::shutdown_called (void) void Sender::add_receiver (Test::Receiver_ptr receiver, - CORBA::Environment &) + CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { + ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); if (this->receiver_count_ == this->receiver_length_) { this->receiver_length_ *= 2; @@ -47,35 +62,79 @@ Sender::add_receiver (Test::Receiver_ptr receiver, void Sender::send_events (CORBA::Long event_count, - CORBA::ULong event_size, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong event_size, + CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { + { + ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); + this->event_count_ = event_count; + } + + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Sender::send_events - starting threads\n")); + + this->sender_task_.run_test (4, event_count, event_size); + + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Sender::send_events - threads are active\n")); +} + +int +Sender::run_test (CORBA::Long event_count, + CORBA::ULong event_size) +{ + ACE_DECLARE_NEW_CORBA_ENV; + Test::Payload payload(event_size); payload.length(event_size); + for (CORBA::ULong j = 0; j != event_size; ++j) + { + payload[j] = CORBA::Octet(j % 256); + } for (CORBA::Long i = 0; i != event_count; ++i) { - ACE_DEBUG ((LM_DEBUG, "(%P|%t) - running iteration %d\n", i)); for (size_t j = 0; j != this->receiver_count_; ++j) { ACE_TRY { - this->receivers_[j]->receive_data (payload, - ACE_TRY_ENV); - ACE_TRY_CHECK; + if (this->test_type_ == Sender::TEST_ONEWAY) + { + this->receivers_[j]->receive_data_oneway (payload, + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + else if (this->test_type_ == Sender::TEST_WRITE) + { + this->receivers_[j]->receive_data (payload, + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + else + { + Test::Payload_var retval = + this->receivers_[j]->return_data (payload, + ACE_TRY_ENV); + ACE_TRY_CHECK; + } + } + ACE_CATCH (CORBA::TRANSIENT, ignored) + { } ACE_CATCHANY { + return -1; } ACE_ENDTRY; } } + return 0; } void Sender::shutdown (CORBA::Environment &) ACE_THROW_SPEC ((CORBA::SystemException)) { - ACE_DEBUG ((LM_DEBUG, "(%P|%t) shutting down\n")); ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, this->mutex_); + ACE_DEBUG ((LM_DEBUG, "(%P|%t) shutting down\n")); this->shutdown_called_ = 1; } diff --git a/TAO/tests/LongWrites/Sender.h b/TAO/tests/LongWrites/Sender.h index 0bcbea6d50e..219d108174a 100644 --- a/TAO/tests/LongWrites/Sender.h +++ b/TAO/tests/LongWrites/Sender.h @@ -7,6 +7,7 @@ #include "ace/pre.h" #include "TestS.h" +#include "Sender_Task.h" #if defined (_MSC_VER) # if (_MSC_VER >= 1200) @@ -22,14 +23,36 @@ class Sender { public: /// Constructor - Sender (void); + Sender (int test_type); /// Destructor virtual ~Sender (void); + /// Control the type of test + enum { + /// Run the test using receive_data_oneway() operations + TEST_ONEWAY, + /// Run the test using receive_data() operations + TEST_WRITE, + /// Run the test using return_data() operations + TEST_READ_WRITE, + }; + + /// Run the test in a separate thread + int run_test (CORBA::Long event_count, + CORBA::ULong event_size); + + /// Return 1 after <shutdown> is invoked and all the messages are + /// received. + int test_done (CORBA::ULong message_count); + /// Return 1 after <shutdown> is invoked int shutdown_called (void); + /// Return 1 if the test is finished, assuming <message_count> + /// messages have been received by the local Receiver + int iteration_done (CORBA::ULong messsage_count); + // = The skeleton methods virtual void add_receiver (Test::Receiver_ptr receiver, CORBA::Environment &ACE_TRY_ENV) @@ -42,13 +65,25 @@ public: ACE_THROW_SPEC ((CORBA::SystemException)); private: + /// The type of test + int test_type_; + + /// Synchronize the internal state ACE_SYNCH_MUTEX mutex_; + /// Keep track of all the receivers size_t receiver_count_; size_t receiver_length_; Test::Receiver_var *receivers_; + /// Set to 1 if the shutdown() operations was called. int shutdown_called_; + + /// Setup event count + CORBA::ULong event_count_; + + /// Used to run the threads + Sender_Task sender_task_; }; #if defined(_MSC_VER) && (_MSC_VER >= 1200) diff --git a/TAO/tests/LongWrites/Sender_Task.cpp b/TAO/tests/LongWrites/Sender_Task.cpp new file mode 100644 index 00000000000..42a94d37f3e --- /dev/null +++ b/TAO/tests/LongWrites/Sender_Task.cpp @@ -0,0 +1,33 @@ +// +// $Id$ +// + +#include "Sender_Task.h" +#include "Sender.h" + +ACE_RCSID(LongWrites, Sender_Task, "$Id$") + +Sender_Task::Sender_Task (Sender *sender) + : sender_ (sender) + , event_count_ (0) + , event_size_ (0) +{ +} + +int +Sender_Task::run_test (int thread_count, + CORBA::Long event_count, + CORBA::ULong event_size) +{ + this->event_count_ = event_count; + this->event_size_ = event_size; + + return this->activate (THR_NEW_LWP | THR_JOINABLE, thread_count, 1); +} + +int +Sender_Task::svc (void) +{ + return this->sender_->run_test (this->event_count_, + this->event_size_); +} diff --git a/TAO/tests/LongWrites/Sender_Task.h b/TAO/tests/LongWrites/Sender_Task.h new file mode 100644 index 00000000000..562923a9df7 --- /dev/null +++ b/TAO/tests/LongWrites/Sender_Task.h @@ -0,0 +1,45 @@ +// +// $Id$ +// + +#ifndef LONGWRITES_SENDER_TASK_H +#define LONGWRITES_SENDER_TASK_H +#include "ace/pre.h" + +#include "tao/corbafwd.h" +#include "ace/Task.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class Sender; + +/// Implement a Task to run the experiments using multiple threads. +class Sender_Task : public ACE_Task_Base +{ +public: + /// Constructor + Sender_Task (Sender *sender); + + /// Run the experiment using the configuration below + int run_test (int thread_count, + CORBA::Long event_count, + CORBA::ULong event_size); + + /// Thread entry point + int svc (void); + +private: + /// Reference to the test interface + Sender *sender_; + + /// Total number of events + CORBA::Long event_count_; + + /// Size of each message + CORBA::ULong event_size_; +}; + +#include "ace/post.h" +#endif /* LONGWRITES_SENDER_TASK_H */ diff --git a/TAO/tests/LongWrites/Test.idl b/TAO/tests/LongWrites/Test.idl index 43d2eb7c3a3..de5dcee47ae 100644 --- a/TAO/tests/LongWrites/Test.idl +++ b/TAO/tests/LongWrites/Test.idl @@ -8,7 +8,13 @@ module Test interface Receiver { /// Receive a big payload - oneway void receive_data (in Payload the_payload); + oneway void receive_data_oneway (in Payload the_payload); + + /// Receive a big payload, using a twoway + void receive_data (in Payload the_payload); + + /// Return the same data, useful to check the server side + Payload return_data (in Payload the_payload); }; interface Sender { @@ -20,7 +26,7 @@ module Test in unsigned long event_size); /// Shutdown the sender - oneway void shutdown(); + void shutdown(); }; interface Coordinator { diff --git a/TAO/tests/LongWrites/client.cpp b/TAO/tests/LongWrites/client.cpp index 5557ded8776..2c890404d66 100644 --- a/TAO/tests/LongWrites/client.cpp +++ b/TAO/tests/LongWrites/client.cpp @@ -8,23 +8,39 @@ ACE_RCSID(LongWrites, client, "$Id$") const char *ior = "file://test.ior"; +int test_type = Sender::TEST_ONEWAY; + int parse_args (int argc, char *argv[]) { - ACE_Get_Opt get_opts (argc, argv, "k:"); + ACE_Get_Opt get_opts (argc, argv, "k:t:"); int c; while ((c = get_opts ()) != -1) switch (c) { case 'k': - ior = get_opts.optarg; - break; + ior = get_opts.optarg; + break; + case 't': + if (ACE_OS_String::strcasecmp(get_opts.optarg, "ONEWAY") == 0) + test_type = Sender::TEST_ONEWAY; + else if (ACE_OS_String::strcasecmp(get_opts.optarg, "WRITE") == 0) + test_type = Sender::TEST_WRITE; + else if (ACE_OS_String::strcasecmp(get_opts.optarg, "READ_WRITE") == 0) + test_type = Sender::TEST_READ_WRITE; + else + ACE_ERROR_RETURN ((LM_ERROR, + "Unknown test type %s\n", + get_opts.optarg), 1); + break; + case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-k <ior>" + "-k <ior> " + "-t <test_type (ONEWAY,WRITE,READ_WRITE)> " "\n", argv [0]), -1); @@ -90,7 +106,7 @@ main (int argc, char *argv[]) Sender *sender_impl; ACE_NEW_RETURN (sender_impl, - Sender, + Sender (test_type), 1); PortableServer::ServantBase_var sender_owner_transfer(sender_impl); @@ -105,18 +121,38 @@ main (int argc, char *argv[]) ACE_TRY_ENV); ACE_TRY_CHECK; - while (!sender_impl->shutdown_called ()) + for (int i = 0; i != 600; ++i) { ACE_Time_Value tv(1, 0); orb->run (tv, ACE_TRY_ENV); ACE_TRY_CHECK; + + CORBA::ULong message_count = + receiver_impl->message_count (); + if (sender_impl->test_done (message_count)) + break; } + ACE_DEBUG ((LM_DEBUG, "(%P|%t) - client event loop done\n")); + + ACE_Thread_Manager::instance ()->wait (); + + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) client - threads finished\n")); root_poa->destroy (1, 1, ACE_TRY_ENV); ACE_TRY_CHECK; orb->destroy (ACE_TRY_ENV); ACE_TRY_CHECK; + + CORBA::ULong message_count = + receiver_impl->message_count (); + if (!sender_impl->test_done (message_count)) + { + ACE_ERROR ((LM_ERROR, + "ERROR: missing messages, only received %d\n", + message_count)); + } } ACE_CATCHANY { @@ -126,5 +162,6 @@ main (int argc, char *argv[]) } ACE_ENDTRY; + ACE_DEBUG ((LM_DEBUG, "(%P|%t) - client finished\n")); return 0; } diff --git a/TAO/tests/LongWrites/run_test.pl b/TAO/tests/LongWrites/run_test.pl index 71eafcca0b4..8b6f21474a8 100755 --- a/TAO/tests/LongWrites/run_test.pl +++ b/TAO/tests/LongWrites/run_test.pl @@ -7,54 +7,76 @@ eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' use lib '../../../bin'; use PerlACE::Run_Test; +use Getopt::Std; + +local ($opt_i, $opt_p); + +if (!getopts ('i:p:')) { + print "Usage: run_test.pl [-p payload_size] [-i iterations]\n"; + exit 1; +} + +my $server_args = ""; +if (defined $opt_i) { + $server_args .= " -i ".$opt_i; +} +if (defined $opt_p) { + $server_args .= " -p ".$opt_p; +} $iorfile = PerlACE::LocalFile ("server.ior"); -unlink $iorfile; -$SV = new PerlACE::Process ("server", "-o $iorfile"); -$CL1 = new PerlACE::Process ("client", " -k file://$iorfile "); -$CL2 = new PerlACE::Process ("client", " -k file://$iorfile "); -$CL3 = new PerlACE::Process ("client", " -k file://$iorfile "); +foreach my $i ("ONEWAY") { # , "WRITE", "READ_WRITE") { + + print "================ Running test $i ================\n"; + + + unlink $iorfile; + $SV = new PerlACE::Process ("server", "-o $iorfile $server_args"); + $CL1 = new PerlACE::Process ("client", " -k file://$iorfile -t $i"); + $CL2 = new PerlACE::Process ("client", " -k file://$iorfile -t $i"); + $CL3 = new PerlACE::Process ("client", " -k file://$iorfile -t $i"); -$SV->Spawn (); + $SV->Spawn (); -if (PerlACE::waitforfile_timed ($iorfile, 5) == -1) { + if (PerlACE::waitforfile_timed ($iorfile, 5) == -1) { print STDERR "ERROR: cannot find file <$iorfile>\n"; $SV->Kill (); $SV->TimedWait (1); exit 1; -} + } -$CL1->Spawn (60); -$CL2->Spawn (60); -$CL3->Spawn (60); + $CL1->Spawn (1200); + $CL2->Spawn (1200); + $CL3->Spawn (1200); -$client1 = $CL1->WaitKill (60); + $client1 = $CL1->WaitKill (60); -if ($client1 != 0) { + if ($client1 != 0) { print STDERR "ERROR: client 1 returned $client1\n"; $status = 1; -} + } -$client2 = $CL2->WaitKill (60); + $client2 = $CL2->WaitKill (60); -if ($client2 != 0) { + if ($client2 != 0) { print STDERR "ERROR: client 2 returned $client2\n"; $status = 1; -} + } -$client3 = $CL3->WaitKill (60); + $client3 = $CL3->WaitKill (60); -if ($client3 != 0) { + if ($client3 != 0) { print STDERR "ERROR: client 3 returned $client3\n"; $status = 1; -} + } -$server = $SV->TerminateWaitKill (5); + $server = $SV->TerminateWaitKill (5); -if ($server != 0) { + if ($server != 0) { print STDERR "ERROR: server returned $server\n"; $status = 1; + } } unlink $iorfile; diff --git a/TAO/tests/LongWrites/server.cpp b/TAO/tests/LongWrites/server.cpp index b57cafb201c..b431d67845b 100644 --- a/TAO/tests/LongWrites/server.cpp +++ b/TAO/tests/LongWrites/server.cpp @@ -8,23 +8,37 @@ ACE_RCSID(LongWrites, server, "$Id$") const char *ior_output_file = "test.ior"; +CORBA::ULong initial_event_size = 64 * 1024; +CORBA::Long test_iterations = 50; + int parse_args (int argc, char *argv[]) { - ACE_Get_Opt get_opts (argc, argv, "o:"); + ACE_Get_Opt get_opts (argc, argv, "o:p:i:"); int c; while ((c = get_opts ()) != -1) switch (c) { case 'o': - ior_output_file = get_opts.optarg; - break; + ior_output_file = get_opts.optarg; + break; + + case 'p': + initial_event_size = ACE_OS::atoi (get_opts.optarg); + break; + + case 'i': + test_iterations = ACE_OS::atoi (get_opts.optarg); + break; + case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " - "-o <iorfile>" + "-o <iorfile> " + "-p <payload_size> " + "-i <test_iterations> " "\n", argv [0]), -1); @@ -64,7 +78,8 @@ main (int argc, char *argv[]) Coordinator *coordinator_impl; ACE_NEW_RETURN (coordinator_impl, - Coordinator, + Coordinator (initial_event_size, + test_iterations), 1); PortableServer::ServantBase_var coordinator_owner_transfer(coordinator_impl); @@ -73,7 +88,7 @@ main (int argc, char *argv[]) ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (coordinator.in (), ACE_TRY_ENV); + orb->object_to_string (coordinator.in (), ACE_TRY_ENV); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -82,7 +97,7 @@ main (int argc, char *argv[]) ACE_ERROR_RETURN ((LM_ERROR, "Cannot open output file for writing IOR: %s", ior_output_file), - 1); + 1); ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); diff --git a/TAO/tests/Makefile b/TAO/tests/Makefile index 717adea4b98..3ef2db30830 100644 --- a/TAO/tests/Makefile +++ b/TAO/tests/Makefile @@ -65,7 +65,12 @@ DIRS = CDR \ Crash_On_Write \ Reliable_Oneways \ Blocking_Sync_None \ - Oneway_Buffering + Oneway_Buffering \ + Queued_Message_Test \ + Big_Oneways \ + Big_Twoways \ + Big_Request_Muxing \ + AMI_Buffering ifndef TAO_ROOT TAO_ROOT = $(ACE_ROOT)/TAO diff --git a/TAO/tests/Makefile.bor b/TAO/tests/Makefile.bor index 558bbb0cea4..85b9632d2f5 100644 --- a/TAO/tests/Makefile.bor +++ b/TAO/tests/Makefile.bor @@ -4,6 +4,7 @@ DIRS = \ AMI \ + AMI_Buffering \ AMI_Timeouts \ Bidirectional \ Bidirectional_NestedUpcall \ diff --git a/TAO/tests/Muxing/run_test.pl b/TAO/tests/Muxing/run_test.pl index 969633d018b..a9031c6e821 100755 --- a/TAO/tests/Muxing/run_test.pl +++ b/TAO/tests/Muxing/run_test.pl @@ -17,7 +17,7 @@ $CL2 = new PerlACE::Process ("client", " -k file://$iorfile"); $SV->Spawn (); -if (PerlACE::waitforfile_timed ($iorfile, 5) == -1) { +if (PerlACE::waitforfile_timed ($iorfile, 15) == -1) { print STDERR "ERROR: cannot find file <$iorfile>\n"; $SV->Kill (); $SV->TimedWait (1); exit 1; diff --git a/TAO/tests/Oneway_Buffering/client.cpp b/TAO/tests/Oneway_Buffering/client.cpp index add62fd6557..7c10393f717 100644 --- a/TAO/tests/Oneway_Buffering/client.cpp +++ b/TAO/tests/Oneway_Buffering/client.cpp @@ -13,6 +13,7 @@ int iterations = 200; int run_message_count_test = 0; int run_timeout_test = 0; +int run_timeout_reactive_test = 0; int run_buffer_size_test = 0; const int PAYLOAD_LENGTH = 1024; @@ -21,7 +22,7 @@ const int TIMEOUT_MILLISECONDS = 50; const int BUFFER_SIZE = 64 * PAYLOAD_LENGTH; /// Check that no more than 10% of the messages are not sent. -const double PROGRESS_TOLERANCE = 0.9; +const double LIVENESS_TOLERANCE = 0.9; /// Factor in GIOP overhead in the buffer size test const double GIOP_OVERHEAD = 0.9; @@ -29,7 +30,7 @@ const double GIOP_OVERHEAD = 0.9; int parse_args (int argc, char *argv[]) { - ACE_Get_Opt get_opts (argc, argv, "k:a:i:ctb"); + ACE_Get_Opt get_opts (argc, argv, "k:a:i:ctbr"); int c; while ((c = get_opts ()) != -1) @@ -59,6 +60,10 @@ parse_args (int argc, char *argv[]) run_buffer_size_test = 1; break; + case 'r': + run_timeout_reactive_test = 1; + break; + case '?': default: ACE_ERROR_RETURN ((LM_ERROR, @@ -66,7 +71,7 @@ parse_args (int argc, char *argv[]) "-k <server_ior> " "-a <admin_ior> " "-i <iterations> " - "<-c|-t|-b> " + "<-c|-t|-b|-r> " "\n", argv [0]), -1); @@ -80,6 +85,7 @@ run_message_count (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, CORBA::Environment &ACE_TRY_ENV); + int run_timeout (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, @@ -87,6 +93,12 @@ run_timeout (CORBA::ORB_ptr orb, CORBA::Environment &ACE_TRY_ENV); int +run_timeout_reactive (CORBA::ORB_ptr orb, + Test::Oneway_Buffering_ptr oneway_buffering, + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, + CORBA::Environment &ACE_TRY_ENV); + +int run_buffer_size (CORBA::ORB_ptr orb, Test::Oneway_Buffering_ptr oneway_buffering, Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, @@ -159,6 +171,17 @@ main (int argc, char *argv[]) ACE_TRY_ENV); ACE_TRY_CHECK; } + else if (run_timeout_reactive_test) + { + ACE_DEBUG ((LM_DEBUG, + "Running timeout (reactive) flushing test\n")); + test_failed = + run_timeout_reactive (orb.in (), + oneway_buffering.in (), + oneway_buffering_admin.in (), + ACE_TRY_ENV); + ACE_TRY_CHECK; + } else if (run_buffer_size_test) { ACE_DEBUG ((LM_DEBUG, @@ -269,16 +292,17 @@ configure_policies (CORBA::ORB_ptr orb, flusher = Test::Oneway_Buffering::_narrow (object.in (), ACE_TRY_ENV); ACE_CHECK_RETURN (-1); - + return 0; } int -run_progress_test (Test::Oneway_Buffering_ptr oneway_buffering, +run_liveness_test (Test::Oneway_Buffering_ptr oneway_buffering, Test::Oneway_Buffering_ptr flusher, Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, CORBA::Environment &ACE_TRY_ENV) { + ACE_DEBUG ((LM_DEBUG, ".... checking for liveness\n")); int test_failed = 0; // Get back in sync with the server... @@ -291,12 +315,14 @@ run_progress_test (Test::Oneway_Buffering_ptr oneway_buffering, oneway_buffering_admin->request_count (ACE_TRY_ENV); ACE_CHECK_RETURN (-1); - int progress_test_iterations = int(send_count); + int liveness_test_iterations = int(send_count); Test::Payload payload (PAYLOAD_LENGTH); payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); - for (int i = 0; i != progress_test_iterations; ++i) + for (int i = 0; i != liveness_test_iterations; ++i) { oneway_buffering->receive_data (payload, ACE_TRY_ENV); ACE_CHECK_RETURN (-1); @@ -310,7 +336,7 @@ run_progress_test (Test::Oneway_Buffering_ptr oneway_buffering, // expect it to fall too far behind, i.e. at least 90% of the // messages should be delivered.... CORBA::ULong expected = - CORBA::ULong (PROGRESS_TOLERANCE * send_count); + CORBA::ULong (LIVENESS_TOLERANCE * send_count); if (receive_count < expected) { @@ -338,7 +364,7 @@ run_message_count (CORBA::ORB_ptr orb, buffering_constraint.message_bytes = 0; buffering_constraint.timeout = 0; - Test::Oneway_Buffering_var flusher; + Test::Oneway_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, oneway_buffering, flusher.out (), @@ -350,6 +376,8 @@ run_message_count (CORBA::ORB_ptr orb, Test::Payload payload (PAYLOAD_LENGTH); payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); CORBA::ULong send_count = 0; for (int i = 0; i != iterations; ++i) @@ -413,14 +441,14 @@ run_message_count (CORBA::ORB_ptr orb, } } - int progress_test_failed = - run_progress_test (oneway_buffering, + int liveness_test_failed = + run_liveness_test (oneway_buffering, flusher.in (), oneway_buffering_admin, ACE_TRY_ENV); ACE_CHECK_RETURN (-1); - if (progress_test_failed) + if (liveness_test_failed) test_failed = 1; return test_failed; @@ -438,7 +466,7 @@ run_timeout (CORBA::ORB_ptr orb, buffering_constraint.message_bytes = 0; buffering_constraint.timeout = TIMEOUT_MILLISECONDS * 10000; - Test::Oneway_Buffering_var flusher; + Test::Oneway_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, oneway_buffering, flusher.out (), @@ -450,6 +478,8 @@ run_timeout (CORBA::ORB_ptr orb, Test::Payload payload (PAYLOAD_LENGTH); payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); CORBA::ULong send_count = 0; for (int i = 0; i != iterations; ++i) @@ -513,15 +543,125 @@ run_timeout (CORBA::ORB_ptr orb, } } } - - int progress_test_failed = - run_progress_test (oneway_buffering, + + int liveness_test_failed = + run_liveness_test (oneway_buffering, + flusher.in (), + oneway_buffering_admin, + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (liveness_test_failed) + test_failed = 1; + + + return test_failed; +} + +int +run_timeout_reactive (CORBA::ORB_ptr orb, + Test::Oneway_Buffering_ptr oneway_buffering, + Test::Oneway_Buffering_Admin_ptr oneway_buffering_admin, + CORBA::Environment &ACE_TRY_ENV) +{ + TAO::BufferingConstraint buffering_constraint; + buffering_constraint.mode = TAO::BUFFER_TIMEOUT; + buffering_constraint.message_count = 0; + buffering_constraint.message_bytes = 0; + buffering_constraint.timeout = TIMEOUT_MILLISECONDS * 10000; + + Test::Oneway_Buffering_var flusher; + int test_failed = + configure_policies (orb, buffering_constraint, + oneway_buffering, flusher.out (), + ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (test_failed != 0) + return test_failed; + + Test::Payload payload (PAYLOAD_LENGTH); + payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); + + CORBA::ULong send_count = 0; + for (int i = 0; i != iterations; ++i) + { + // Get back in sync with the server... + flusher->flush (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + flusher->sync (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + CORBA::ULong initial_receive_count = + oneway_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + if (initial_receive_count != send_count) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d message lost (%u != %u)\n", + i, initial_receive_count, send_count)); + } + + ACE_Time_Value start = ACE_OS::gettimeofday (); + for (int j = 0; j != 20; ++j) + { + oneway_buffering->receive_data (payload, ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + send_count++; + } + while (1) + { + CORBA::ULong receive_count = + oneway_buffering_admin->request_count (ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + ACE_Time_Value sleep (0, 10000); + orb->run (sleep, ACE_TRY_ENV); + ACE_CHECK_RETURN (-1); + + ACE_Time_Value elapsed = ACE_OS::gettimeofday () - start; + if (receive_count != initial_receive_count) + { + if (elapsed.msec () < TIMEOUT_MILLISECONDS) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d flush before " + "timeout expired. " + "Elapsed = %d, Timeout = %d msecs\n", + i, + elapsed.msec (), TIMEOUT_MILLISECONDS)); + } + // terminate the while loop. + break; + } + + if (elapsed.msec () > 2 * TIMEOUT_MILLISECONDS) + { + test_failed = 1; + ACE_ERROR ((LM_ERROR, + "ERROR: Iteration %d no flush past " + "timeout threshold. " + "Elapsed = %d, Timeout = %d msecs\n", + i, + elapsed.msec (), TIMEOUT_MILLISECONDS)); + break; + } + } + } + + int liveness_test_failed = + run_liveness_test (oneway_buffering, flusher.in (), oneway_buffering_admin, ACE_TRY_ENV); ACE_CHECK_RETURN (-1); - if (progress_test_failed) + if (liveness_test_failed) test_failed = 1; @@ -540,7 +680,7 @@ run_buffer_size (CORBA::ORB_ptr orb, buffering_constraint.message_bytes = BUFFER_SIZE; buffering_constraint.timeout = 0; - Test::Oneway_Buffering_var flusher; + Test::Oneway_Buffering_var flusher; int test_failed = configure_policies (orb, buffering_constraint, oneway_buffering, flusher.out (), @@ -552,6 +692,8 @@ run_buffer_size (CORBA::ORB_ptr orb, Test::Payload payload (PAYLOAD_LENGTH); payload.length (PAYLOAD_LENGTH); + for (int j = 0; j != PAYLOAD_LENGTH; ++j) + payload[j] = CORBA::Octet(j % 256); CORBA::ULong bytes_sent = 0; for (int i = 0; i != iterations; ++i) @@ -620,14 +762,14 @@ run_buffer_size (CORBA::ORB_ptr orb, } } - int progress_test_failed = - run_progress_test (oneway_buffering, + int liveness_test_failed = + run_liveness_test (oneway_buffering, flusher.in (), oneway_buffering_admin, ACE_TRY_ENV); ACE_CHECK_RETURN (-1); - if (progress_test_failed) + if (liveness_test_failed) test_failed = 1; return test_failed; diff --git a/TAO/tests/Oneway_Buffering/run_test.pl b/TAO/tests/Oneway_Buffering/run_test.pl index 30593090375..99a64dd9dd5 100755 --- a/TAO/tests/Oneway_Buffering/run_test.pl +++ b/TAO/tests/Oneway_Buffering/run_test.pl @@ -11,7 +11,7 @@ use PerlACE::Run_Test; $admin_iorfile = PerlACE::LocalFile ("admin.ior"); $server_iorfile = PerlACE::LocalFile ("server.ior"); -foreach $test_type ("-c", "-t", "-b") { +foreach $test_type ("-c", "-t", "-b", "-r") { unlink $admin_iorfile; unlink $server_iorfile; diff --git a/TAO/tests/Oneway_Buffering/run_timeout_reactive.pl b/TAO/tests/Oneway_Buffering/run_timeout_reactive.pl new file mode 100755 index 00000000000..31f09190b88 --- /dev/null +++ b/TAO/tests/Oneway_Buffering/run_timeout_reactive.pl @@ -0,0 +1,65 @@ +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# $Id$ +# -*- perl -*- + +use lib '../../../bin'; +use PerlACE::Run_Test; + +$admin_iorfile = PerlACE::LocalFile ("admin.ior"); +$server_iorfile = PerlACE::LocalFile ("server.ior"); + +unlink $admin_iorfile; +unlink $server_iorfile; + +my $AD = new PerlACE::Process ("admin", "-o $admin_iorfile"); +my $SV = new PerlACE::Process ("server", "-o $server_iorfile"); +my $CL = new PerlACE::Process ("client", + " -k file://$server_iorfile " + ."-a file://$admin_iorfile " + ."-r "); + +$AD->Spawn (); + +if (PerlACE::waitforfile_timed ($admin_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$admin_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + exit 1; +} + +$SV->Spawn (); + +if (PerlACE::waitforfile_timed ($server_iorfile, 10) == -1) { + print STDERR "ERROR: cannot find file <$server_iorfile>\n"; + $AD->Kill (); $AD->TimedWait (1); + $SV->Kill (); $SV->TimedWait (1); + exit 1; +} + +$client = $CL->SpawnWaitKill (300); + +if ($client != 0) { + print STDERR "ERROR: client returned $client\n"; + $status = 1; +} + +$server = $SV->WaitKill (10); + +if ($server != 0) { + print STDERR "ERROR: server returned $server\n"; + $status = 1; +} + +$admin = $AD->WaitKill (10); + +if ($admin != 0) { + print STDERR "ERROR: admin returned $admin\n"; + $status = 1; +} + +unlink $server_iorfile; +unlink $admin_iorfile; + +exit $status; diff --git a/TAO/tests/Queued_Message_Test/Makefile b/TAO/tests/Queued_Message_Test/Makefile new file mode 100644 index 00000000000..176100a9d75 --- /dev/null +++ b/TAO/tests/Queued_Message_Test/Makefile @@ -0,0 +1,154 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +LDLIBS = -lTAO + +IDL_FILES = +IDL_SRC = +BIN = Queued_Message_Test + +SRC = $(addsuffix .cpp, $(BIN)) $(IDL_SRC) + +QUEUED_MESSAGE_OBJS = Queued_Message_Test.o + +TAO_IDLFLAGS += -Ge 1 +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +.PRECIOUS: $(foreach ext, $(IDL_EXT), Test$(ext)) + +Queued_Message_Test: $(addprefix $(VDIR),$(QUEUED_MESSAGE_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(TAO_CLNT_LIBS) $(POSTLINK) + +realclean: clean + -$(RM) $(foreach ext, $(IDL_EXT), Test$(ext)) + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +.obj/Queued_Message_Test.o .obj/Queued_Message_Test.so .shobj/Queued_Message_Test.o .shobj/Queued_Message_Test.so: Queued_Message_Test.cpp \ + $(TAO_ROOT)/tao/Queued_Message.h \ + $(ACE_ROOT)/ace/pre.h \ + $(TAO_ROOT)/tao/corbafwd.h \ + $(ACE_ROOT)/ace/CDR_Base.h \ + $(ACE_ROOT)/ace/post.h \ + $(ACE_ROOT)/ace/ACE_export.h \ + $(ACE_ROOT)/ace/svc_export.h \ + $(ACE_ROOT)/ace/ace_wchar.h \ + $(ACE_ROOT)/ace/ace_wchar.inl \ + $(ACE_ROOT)/ace/OS_Errno.h \ + $(ACE_ROOT)/ace/OS_Export.h \ + $(ACE_ROOT)/ace/OS_Errno.inl \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/OS_Dirent.h \ + $(ACE_ROOT)/ace/OS_Dirent.inl \ + $(ACE_ROOT)/ace/OS_String.h \ + $(ACE_ROOT)/ace/OS_String.inl \ + $(ACE_ROOT)/ace/OS_Memory.h \ + $(ACE_ROOT)/ace/OS_Memory.inl \ + $(ACE_ROOT)/ace/OS_TLI.h \ + $(ACE_ROOT)/ace/OS_TLI.inl \ + $(ACE_ROOT)/ace/Min_Max.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Flag_Manip.h \ + $(ACE_ROOT)/ace/Flag_Manip.i \ + $(ACE_ROOT)/ace/Handle_Ops.h \ + $(ACE_ROOT)/ace/Handle_Ops.i \ + $(ACE_ROOT)/ace/Lib_Find.h \ + $(ACE_ROOT)/ace/Lib_Find.i \ + $(ACE_ROOT)/ace/Init_ACE.h \ + $(ACE_ROOT)/ace/Init_ACE.i \ + $(ACE_ROOT)/ace/Sock_Connect.h \ + $(ACE_ROOT)/ace/Sock_Connect.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.h \ + $(ACE_ROOT)/ace/OS_Log_Msg_Attributes.inl \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.h \ + $(ACE_ROOT)/ace/Base_Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread_Adapter.inl \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Malloc_Allocator.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc_Allocator.i \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers_T.h \ + $(ACE_ROOT)/ace/Containers_T.i \ + $(ACE_ROOT)/ace/Containers_T.cpp \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/Message_Block_T.h \ + $(ACE_ROOT)/ace/Message_Block_T.i \ + $(ACE_ROOT)/ace/Message_Block_T.cpp \ + $(ACE_ROOT)/ace/CDR_Base.inl \ + $(TAO_ROOT)/tao/try_macros.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/CORBA_macros.h \ + $(TAO_ROOT)/tao/varbase.h \ + $(TAO_ROOT)/tao/TAO_Export.h \ + $(TAO_ROOT)/tao/corbafwd.i \ + $(TAO_ROOT)/tao/Queued_Message.inl + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/tests/Queued_Message_Test/Queued_Message_Test.cpp b/TAO/tests/Queued_Message_Test/Queued_Message_Test.cpp new file mode 100644 index 00000000000..2742e76a92b --- /dev/null +++ b/TAO/tests/Queued_Message_Test/Queued_Message_Test.cpp @@ -0,0 +1,163 @@ +// ============================================================================ +/** + * @brief Unit test for the TAO_Queued_Message class + * + * $Id$ + * + * @author Carlos O'Ryan <coryan@uci.edu> + */ +// ============================================================================ + +#include "tao/Asynch_Queued_Message.h" + +ACE_RCSID(tests, Queued_Message_Test, "$Id$") + +/// Max number of bytes on each message block +const size_t max_block_length = 256; + +static TAO_Queued_Message * +create_new_message (ACE_RANDR_TYPE &seed) +{ + // First create a message block + size_t block_size = + 64 + ACE_OS::rand_r(seed) % (max_block_length - 64); + ACE_Message_Block mb (block_size); + mb.wr_ptr (block_size); + + return new TAO_Asynch_Queued_Message (&mb); +} + +/// Add a new message at the tail of the queue. +static void push_back_message (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail, + ACE_RANDR_TYPE &seed) +{ + TAO_Queued_Message *msg = create_new_message (seed); + msg->push_back (head, tail); +} + +/// Add a new message at the head of the queue. +static void push_front_message (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail, + ACE_RANDR_TYPE &seed) +{ + TAO_Queued_Message *msg = create_new_message (seed); + msg->push_front (head, tail); +} + +/// Remove the message at the head of the queue, and simulate the +/// behavior of the I/O subsystem when processing such messages. +static void del_message (TAO_Queued_Message *&head, + TAO_Queued_Message *&tail, + ACE_RANDR_TYPE &seed) +{ + // ACE_DEBUG ((LM_DEBUG, "Removing message\n")); + TAO_Queued_Message *current = head; + current->remove_from_list (head, tail); + + // Simulate message writing: each message is 'sent' using + // multiple write() calls, in this simulation, we call the + // bytes_transferred() method until all messages are removed. + + size_t total_length = current->message_length (); + while (total_length > 0) + { + // select how many bytes we want to 'send' in this iteration. + size_t t = ACE_OS::rand_r(seed) % 256 + 1; + if (t > total_length) + t = total_length; + + current->bytes_transferred (t); + total_length -= t; + } + if (!current->all_data_sent ()) + { + ACE_ERROR ((LM_DEBUG, + "ERROR: inconsistent state in Queued_Message\n")); + ACE_OS::exit (1); + } + current->destroy (); +} + +int +main (int, ACE_TCHAR *[]) +{ + + // Initialize a random seed to get better coverage. + // @@ The random seed and default values should be configurable + // using command line options. + + ACE_hrtime_t current_hrtime = ACE_OS::gethrtime (); + ACE_UINT32 low_bits = + ACE_CU64_TO_CU32(current_hrtime); + ACE_RANDR_TYPE seed = + ACE_static_cast(ACE_RANDR_TYPE,low_bits); + + ACE_DEBUG ((LM_DEBUG, "Running test SEED = %d\n", seed)); + + TAO_Queued_Message *head = 0; + TAO_Queued_Message *tail = 0; + + int add_count = 0; + int del_count = 0; + + const int iterations = 100; + int i; + for (i = 0; i != iterations; ++i) + { + push_back_message (head, tail, seed); + add_count++; + if (ACE_OS::rand_r(seed) % 100 > 90) + { + // every so often remove a message also. + if (head != 0) + { + del_message (head, tail, seed); + del_count++; + } + } + } + + // second phase, change the probabilities of removing a message. + for (i = 0; i != iterations; ++i) + { + if (ACE_OS::rand_r(seed) % 100 > 90) + { + push_back_message (head, tail, seed); add_count++; + } + if (ACE_OS::rand_r(seed) % 100 > 90) + { + push_front_message (head, tail, seed); add_count++; + } + if (head != 0) + { + del_message (head, tail, seed); + del_count++; + } + } + + // Go through a phase where all messages are removed. + while (head != 0) + { + del_message (head, tail, seed); + del_count++; + } + + if (tail != 0) + { + ACE_ERROR_RETURN ((LM_ERROR, + "ERROR: inconsistent state in message queue\n"), + 1); + } + + if (add_count != del_count) + { + ACE_ERROR_RETURN ((LM_ERROR, + "ERROR: mismatched (%d != %d) add and del counts\n", + add_count, del_count), + 1); + } + + + return 0; +} diff --git a/TAO/tests/Queued_Message_Test/Queued_Message_Test.dsp b/TAO/tests/Queued_Message_Test/Queued_Message_Test.dsp new file mode 100644 index 00000000000..33afc8707d1 --- /dev/null +++ b/TAO/tests/Queued_Message_Test/Queued_Message_Test.dsp @@ -0,0 +1,96 @@ +# Microsoft Developer Studio Project File - Name="Queued_Message_Test" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Queued_Message_Test - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "Queued_Message_Test.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Queued_Message_Test.mak" CFG="Queued_Message_Test - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "Queued_Message_Test - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Queued_Message_Test - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "Queued_Message_Test - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\.." /I "..\..\.." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ace.lib tao.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\tao" /libpath:"..\..\..\ace"
+
+!ELSEIF "$(CFG)" == "Queued_Message_Test - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\.." /I "..\..\.." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 aced.lib TAOd.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\tao" /libpath:"..\..\..\ace"
+
+!ENDIF
+
+# Begin Target
+
+# Name "Queued_Message_Test - Win32 Release"
+# Name "Queued_Message_Test - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=.\Queued_Message_Test.cpp
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/tests/Queued_Message_Test/Queued_Message_Test.dsw b/TAO/tests/Queued_Message_Test/Queued_Message_Test.dsw new file mode 100644 index 00000000000..03521d0402c --- /dev/null +++ b/TAO/tests/Queued_Message_Test/Queued_Message_Test.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Queued_Message_Test"=.\Queued_Message_Test.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/TAO/tests/README b/TAO/tests/README index e03bd5ca19d..34da58a9f87 100644 --- a/TAO/tests/README +++ b/TAO/tests/README @@ -8,11 +8,31 @@ how to run the following tests: This is a simple test for AMI callback model. + . AMI_Buffering + + Test the buffering constraint policy when applied to AMI + requests. + . AMI_Timeouts This is a simple test for AMI callback model in combination with timeouts (relative roundtrip timeout policy). + . Big_Oneways + + Stress test non-blocking I/O features in the ORB. + + . Big_Twoways + + More stress testing for the non-blocking I/O features in the + ORB, this time also test receiving big blocks of data. + + . Big_Requests_Muxing + + More stress testing for the non-blocking I/O features in the + ORB, this time we send reliable and unreliable oneways + through the same connection. + . Bidirectional This is a test that exercises the birectional GIOP connection diff --git a/TAO/tests/Reliable_Oneways/Test.idl b/TAO/tests/Reliable_Oneways/Test.idl index 39593d25d78..a083bd6412c 100644 --- a/TAO/tests/Reliable_Oneways/Test.idl +++ b/TAO/tests/Reliable_Oneways/Test.idl @@ -24,6 +24,6 @@ module Test interface Shutdown_Helper { /// Shutdown the server - oneway void shutdown (); + void shutdown (); }; }; diff --git a/TAO/tests/Timeout/client.cpp b/TAO/tests/Timeout/client.cpp index 124d806be64..11e3f62e6a3 100644 --- a/TAO/tests/Timeout/client.cpp +++ b/TAO/tests/Timeout/client.cpp @@ -47,6 +47,9 @@ parse_args (int argc, char *argv[]) return 0; } +static int timeout_count = 0; +static int in_time_count = 0; + void send_echo (CORBA::ORB_ptr orb, Simple_Server_ptr server, @@ -58,9 +61,12 @@ send_echo (CORBA::ORB_ptr orb, server->echo (0, t, ACE_TRY_ENV); ACE_TRY_CHECK; + in_time_count++; } ACE_CATCH (CORBA::TIMEOUT, timeout) { + timeout_count++; + // Trap this exception and continue... // ACE_DEBUG ((LM_DEBUG, // "==> Trapped a TIMEOUT exception (expected)\n")); @@ -242,10 +248,25 @@ int main (int argc, char* argv[]) server->shutdown (ACE_TRY_ENV); ACE_TRY_CHECK; + + if (timeout_count == 0) + { + ACE_ERROR ((LM_ERROR, "ERROR: No messaged timed out\n")); + } + if (in_time_count == 0) + { + ACE_ERROR ((LM_ERROR, "ERROR: No messages on time\n")); + } + + ACE_DEBUG ((LM_DEBUG, "In time = %d, timed out = %d\n", + in_time_count, timeout_count)); + + orb->destroy (ACE_TRY_ENV); + ACE_TRY_CHECK; } ACE_CATCHANY { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Catched exception:"); + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); return 1; } ACE_ENDTRY; |