diff options
Diffstat (limited to 'TAO/performance-tests')
98 files changed, 3714 insertions, 560 deletions
diff --git a/TAO/performance-tests/AMI_Latency/Roundtrip.cpp b/TAO/performance-tests/AMI_Latency/Roundtrip.cpp new file mode 100644 index 00000000000..c9e68d98406 --- /dev/null +++ b/TAO/performance-tests/AMI_Latency/Roundtrip.cpp @@ -0,0 +1,26 @@ +// +// $Id$ +// +#include "Roundtrip.h" + +ACE_RCSID(AMI_Latency, Roundtrip, "$Id$") + +Roundtrip::Roundtrip (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +Test::Timestamp +Roundtrip::test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return send_time; +} + +void +Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} diff --git a/TAO/performance-tests/AMI_Latency/Roundtrip.h b/TAO/performance-tests/AMI_Latency/Roundtrip.h new file mode 100644 index 00000000000..efef33dd7e6 --- /dev/null +++ b/TAO/performance-tests/AMI_Latency/Roundtrip.h @@ -0,0 +1,46 @@ +// +// $Id$ +// + +#ifndef ROUNDTRIP_H +#define ROUNDTRIP_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::Roundtrip interface +class Roundtrip + : public virtual POA_Test::Roundtrip + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Roundtrip (CORBA::ORB_ptr orb); + + // = The skeleton methods + virtual Test::Timestamp test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ROUNDTRIP_H */ diff --git a/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.cpp b/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.cpp new file mode 100644 index 00000000000..5f0061601e4 --- /dev/null +++ b/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.cpp @@ -0,0 +1,75 @@ +// +// $Id$ +// +#include "Roundtrip_Handler.h" + +ACE_RCSID(AMI_Latency, Roundtrip, "$Id$") + +Roundtrip_Handler::Roundtrip_Handler (int expected_callbacks) + : pending_callbacks_ (expected_callbacks) +{ +} + +int +Roundtrip_Handler::pending_callbacks (void) const +{ + return this->pending_callbacks_; +} + +void +Roundtrip_Handler::dump_results (ACE_UINT32 gsf) +{ + this->latency_stats_.dump_results ("AMI Latency", gsf); +} + +void +Roundtrip_Handler::test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->pending_callbacks_--; + + ACE_hrtime_t now = ACE_OS::gethrtime (); + this->latency_stats_.sample (now - send_time); +} + +void +Roundtrip_Handler::test_method_excep (Test::AMI_RoundtripExceptionHolder *holder + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_TRY + { + this->pending_callbacks_--; + holder->raise_test_method (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "test_method:"); + } + ACE_ENDTRY; +} + +void +Roundtrip_Handler::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ +} + +void +Roundtrip_Handler::shutdown_excep (Test::AMI_RoundtripExceptionHolder *holder + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + ACE_TRY + { + holder->raise_shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "shutdown:"); + } + ACE_ENDTRY; +} diff --git a/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.h b/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.h new file mode 100644 index 00000000000..ae777f50f20 --- /dev/null +++ b/TAO/performance-tests/AMI_Latency/Roundtrip_Handler.h @@ -0,0 +1,61 @@ +// +// $Id$ +// + +#ifndef ROUNDTRIP_HANDLER_H +#define ROUNDTRIP_HANDLER_H +#include "ace/pre.h" + +#include "TestS.h" +#include "ace/Basic_Stats.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::Roundtrip interface +class Roundtrip_Handler + : public virtual POA_Test::AMI_RoundtripHandler + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Roundtrip_Handler (int expected_callbacks); + + /// Return the number of pending callbacks + int pending_callbacks (void) const; + + /// Dump the results + void dump_results (ACE_UINT32 gsf); + + // = The skeleton methods + virtual void test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual void test_method_excep (Test::AMI_RoundtripExceptionHolder *holder + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + virtual void shutdown_excep (Test::AMI_RoundtripExceptionHolder *holder + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// The number of callbacks not received yet + int pending_callbacks_; + + /// Collect the latency results + ACE_Basic_Stats latency_stats_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ROUNDTRIP_H */ diff --git a/TAO/performance-tests/AMI_Latency/Server_Task.cpp b/TAO/performance-tests/AMI_Latency/Server_Task.cpp new file mode 100644 index 00000000000..6df92f32a3f --- /dev/null +++ b/TAO/performance-tests/AMI_Latency/Server_Task.cpp @@ -0,0 +1,24 @@ +// +// $Id$ +// +#include "Server_Task.h" + +ACE_RCSID(AMI_Latency, Server_Task, "$Id$") + +Server_Task::Server_Task (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +int +Server_Task::svc (void) +{ + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + this->orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY {} ACE_ENDTRY; + return 0; +} diff --git a/TAO/performance-tests/AMI_Latency/client.cpp b/TAO/performance-tests/AMI_Latency/client.cpp new file mode 100644 index 00000000000..0d396c4b67b --- /dev/null +++ b/TAO/performance-tests/AMI_Latency/client.cpp @@ -0,0 +1,185 @@ +// $Id$ + +#include "Roundtrip_Handler.h" +#include "tao/debug.h" +#include "ace/Get_Opt.h" +#include "ace/High_Res_Timer.h" +#include "ace/Sched_Params.h" +#include "ace/Stats.h" + +ACE_RCSID(AMI_Latency, client, "$Id$") + +const char *ior = "file://test.ior"; + +ACE_hrtime_t throughput_base; + +int niterations = 1000; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "k:i:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "-i <niterations> " + "-p <period (msecs)> " + "-b <burst size> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "server (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "server (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + 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_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Test::Roundtrip_var roundtrip = + Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (roundtrip.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + "Nil Test::Roundtrip reference <%s>\n", + ior), + 1); + + for (int j = 0; j < 100; ++j) + { + ACE_hrtime_t start = 0; + (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + Roundtrip_Handler *roundtrip_handler_impl; + ACE_NEW_RETURN (roundtrip_handler_impl, + Roundtrip_Handler (niterations), + 1); + PortableServer::ServantBase_var owner_transfer(roundtrip_handler_impl); + + Test::AMI_RoundtripHandler_var roundtrip_handler = + roundtrip_handler_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_hrtime_t test_start = ACE_OS::gethrtime (); + + for (int i = 0; i != niterations; ++i) + { + // Invoke asynchronous operation.... + roundtrip->sendc_test_method (roundtrip_handler.in (), + ACE_OS::gethrtime () + ACE_ENV_ARG_PARAMETER); + if (orb->work_pending (ACE_ENV_SINGLE_ARG_PARAMETER)) + orb->perform_work (ACE_ENV_SINGLE_ARG_PARAMETER); + + ACE_TRY_CHECK; + } + + ACE_Time_Value tv (0, 2000); + + while (roundtrip_handler_impl->pending_callbacks ()) + { + orb->perform_work (tv ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + ACE_hrtime_t test_end = ACE_OS::gethrtime (); + + ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration....")); + ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); + ACE_DEBUG ((LM_DEBUG, "done\n")); + + roundtrip_handler_impl->dump_results (gsf); + + ACE_Throughput_Stats::dump_throughput ("Total", gsf, + test_end - test_start, + niterations); + + roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught: "); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/AMI_Latency/server.cpp b/TAO/performance-tests/AMI_Latency/server.cpp new file mode 100644 index 00000000000..74498dc13e0 --- /dev/null +++ b/TAO/performance-tests/AMI_Latency/server.cpp @@ -0,0 +1,155 @@ +// $Id$ + +#include "Roundtrip.h" +#include "Server_Task.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(AMI_Latency, server, "$Id$") + +const char *ior_output_file = "test.ior"; +int nthreads = 4; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "o:n:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'o': + ior_output_file = get_opts.opt_arg (); + break; + + case 'n': + nthreads = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-o <iorfile> " + "-n <nthreads> " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority); + + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority); + + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "server (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "server (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + 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_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Roundtrip *roundtrip_impl; + ACE_NEW_RETURN (roundtrip_impl, + Roundtrip (orb.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(roundtrip_impl); + + Test::Roundtrip_var roundtrip = + roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER); + 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_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + Server_Task server_task (orb.in ()); + if (server_task.activate (THR_NEW_LWP | THR_JOINABLE, + nthreads) != 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot activate server threads\n"), + 1); + + server_task.thr_mgr ()->wait (); + + ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Callback/Callback_i.cpp b/TAO/performance-tests/Callback/Callback_i.cpp index f86c6f605cb..83e357965ce 100644 --- a/TAO/performance-tests/Callback/Callback_i.cpp +++ b/TAO/performance-tests/Callback/Callback_i.cpp @@ -18,7 +18,7 @@ Callback_i::done (void) void Callback_i::response (Test::TimeStamp time_stamp, const Test::Payload & - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_hrtime_t now = ACE_OS::gethrtime (); diff --git a/TAO/performance-tests/Callback/Callback_i.h b/TAO/performance-tests/Callback/Callback_i.h index 95b9850ee4e..b3423a573b0 100644 --- a/TAO/performance-tests/Callback/Callback_i.h +++ b/TAO/performance-tests/Callback/Callback_i.h @@ -23,7 +23,7 @@ public: //@{ void response (Test::TimeStamp, const Test::Payload & - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); //@} diff --git a/TAO/performance-tests/Callback/Server_i.cpp b/TAO/performance-tests/Callback/Server_i.cpp index 67c2780de3e..a4cc4de2484 100644 --- a/TAO/performance-tests/Callback/Server_i.cpp +++ b/TAO/performance-tests/Callback/Server_i.cpp @@ -10,7 +10,7 @@ ACE_RCSID(Callback, Server_i, "$Id$") void Server_i::set_callback (Test::Callback_ptr callback - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->callback_ = Test::Callback::_duplicate (callback); @@ -19,17 +19,17 @@ Server_i::set_callback (Test::Callback_ptr callback void Server_i::request (Test::TimeStamp time_stamp, const Test::Payload &payload - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (CORBA::is_nil (this->callback_.in ())) return; - this->callback_->response (time_stamp, payload TAO_ENV_ARG_PARAMETER); + this->callback_->response (time_stamp, payload ACE_ENV_ARG_PARAMETER); } void -Server_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Server_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { this->done_ = 1; diff --git a/TAO/performance-tests/Callback/Server_i.h b/TAO/performance-tests/Callback/Server_i.h index 5cf73c65ce7..60887393721 100644 --- a/TAO/performance-tests/Callback/Server_i.h +++ b/TAO/performance-tests/Callback/Server_i.h @@ -18,15 +18,15 @@ public: /// Implement the CORBA methods //@{ void set_callback (Test::Callback_ptr callback - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); void request (Test::TimeStamp, const Test::Payload & - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) + void shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); //@} diff --git a/TAO/performance-tests/Callback/client.cpp b/TAO/performance-tests/Callback/client.cpp index e8af409d5a4..56743477b20 100644 --- a/TAO/performance-tests/Callback/client.cpp +++ b/TAO/performance-tests/Callback/client.cpp @@ -73,17 +73,17 @@ main (int argc, char *argv []) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var manager_object = orb->resolve_initial_references ("ORBPolicyManager" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (manager_object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Any sync_scope; @@ -94,15 +94,15 @@ main (int argc, char *argv []) policy_list[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, sync_scope - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_manager->set_policy_overrides (policy_list, CORBA::SET_OVERRIDE - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -111,14 +111,14 @@ main (int argc, char *argv []) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -126,11 +126,11 @@ main (int argc, char *argv []) // Get the event channel object reference CORBA::Object_var object = - orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Server_var server = - Test::Server::_narrow (object.in () TAO_ENV_ARG_PARAMETER); + Test::Server::_narrow (object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) { @@ -143,10 +143,10 @@ main (int argc, char *argv []) Callback_i callback_i (iterations); - Test::Callback_var callback = callback_i._this (TAO_ENV_SINGLE_ARG_PARAMETER); + Test::Callback_var callback = callback_i._this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - server->set_callback (callback.in () TAO_ENV_ARG_PARAMETER); + server->set_callback (callback.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Connected callback\n")); @@ -158,7 +158,7 @@ main (int argc, char *argv []) while (!callback_i.done () || !task.done ()) { ACE_Time_Value tv (1, 0); - orb->run (tv TAO_ENV_ARG_PARAMETER); + orb->run (tv ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_hrtime_t end = ACE_OS::gethrtime (); @@ -188,15 +188,15 @@ main (int argc, char *argv []) end - start, stats.samples_count ()); - server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + server->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::ObjectId_var id = - root_poa->servant_to_id (&callback_i TAO_ENV_ARG_PARAMETER); + root_poa->servant_to_id (&callback_i ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->deactivate_object (id.in () TAO_ENV_ARG_PARAMETER); + root_poa->deactivate_object (id.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::Exception, ex) @@ -270,7 +270,7 @@ Task::svc (void) for (;;) { Test::TimeStamp creation = ACE_OS::gethrtime (); - this->server_->request (creation, payload TAO_ENV_ARG_PARAMETER); + this->server_->request (creation, payload ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // ACE_Time_Value tv (0, 5000); diff --git a/TAO/performance-tests/Callback/server.cpp b/TAO/performance-tests/Callback/server.cpp index cd0cec3d909..cd7874e13a7 100644 --- a/TAO/performance-tests/Callback/server.cpp +++ b/TAO/performance-tests/Callback/server.cpp @@ -42,17 +42,17 @@ main (int argc, char *argv []) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var manager_object = orb->resolve_initial_references ("ORBPolicyManager" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (manager_object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Any sync_scope; @@ -63,15 +63,15 @@ main (int argc, char *argv []) policy_list[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, sync_scope - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policy_manager->set_policy_overrides (policy_list, CORBA::SET_OVERRIDE - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -80,14 +80,14 @@ main (int argc, char *argv []) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -95,11 +95,11 @@ main (int argc, char *argv []) Server_i server_i; - Test::Server_var server = server_i._this (TAO_ENV_SINGLE_ARG_PARAMETER); + Test::Server_var server = server_i._this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var str = - orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); + orb->object_to_string (server.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (ior_file_name != 0) @@ -117,16 +117,16 @@ main (int argc, char *argv []) while (!server_i.done ()) { ACE_Time_Value tv (1, 0); - orb->run (tv TAO_ENV_ARG_PARAMETER); + orb->run (tv ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } PortableServer::ObjectId_var id = - root_poa->servant_to_id (&server_i TAO_ENV_ARG_PARAMETER); - root_poa->deactivate_object (id.in () TAO_ENV_ARG_PARAMETER); + root_poa->servant_to_id (&server_i ACE_ENV_ARG_PARAMETER); + root_poa->deactivate_object (id.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::Exception, ex) diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp index 09a07be02fd..4c17c253c65 100644 --- a/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp +++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp @@ -201,7 +201,7 @@ DII_Cubit_Client::init (int argc, char **argv) this->orb_var_ = CORBA::ORB_init (this->argc_, this->argv_, "internet" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse command line and verify parameters. @@ -214,12 +214,12 @@ DII_Cubit_Client::init (int argc, char **argv) // Get a factory object reference from the factory IOR. this->factory_var_ = this->orb_var_->string_to_object (this->factory_IOR_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get a Cubit object with a DII request on the Cubit factory. CORBA::Request_var mc_req (this->factory_var_->_request ("make_cubit" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; @@ -233,7 +233,7 @@ DII_Cubit_Client::init (int argc, char **argv) // Invoke the <make_cubit> operation to ask the Cubit factory // for a Cubit object. - mc_req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); + mc_req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Extract the returned object reference from the request. @@ -388,7 +388,7 @@ DII_Cubit_Client::cube_short_dii (void) { // Create the request ... CORBA::Request_var req (this->obj_var_->_request ("cube_short" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; @@ -402,7 +402,7 @@ DII_Cubit_Client::cube_short_dii (void) this->call_count_++; - req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; req->return_value () >>= ret_short; @@ -432,7 +432,7 @@ DII_Cubit_Client::cube_long_dii (void) { // Create the request ... CORBA::Request_var req (this->obj_var_->_request ("cube_long" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; @@ -446,7 +446,7 @@ DII_Cubit_Client::cube_long_dii (void) this->call_count_++; - req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -477,7 +477,7 @@ DII_Cubit_Client::cube_octet_dii (void) { // Create the request ... CORBA::Request_var req (this->obj_var_->_request ("cube_octet" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; @@ -493,7 +493,7 @@ DII_Cubit_Client::cube_octet_dii (void) // Invoke, check for an exception and verify the result. this->call_count_++; - req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -525,7 +525,7 @@ DII_Cubit_Client::cube_union_dii (void) { // Create the request ... CORBA::Request_var req (this->obj_var_->_request ("cube_union" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; @@ -545,7 +545,7 @@ DII_Cubit_Client::cube_union_dii (void) this->call_count_++; - req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -580,7 +580,7 @@ DII_Cubit_Client::cube_struct_dii (void) { // Create the request ... CORBA::Request_var req (this->obj_var_->_request ("cube_struct" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; @@ -599,7 +599,7 @@ DII_Cubit_Client::cube_struct_dii (void) this->call_count_++; - req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -632,7 +632,7 @@ DII_Cubit_Client::cube_octet_seq_dii (int length) { // Create the request ... CORBA::Request_var req (this->obj_var_->_request ("cube_octet_sequence" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; @@ -652,7 +652,7 @@ DII_Cubit_Client::cube_octet_seq_dii (int length) this->call_count_++; - req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -693,7 +693,7 @@ DII_Cubit_Client::cube_long_seq_dii (int length) { // Create the request ... CORBA::Request_var req (this->obj_var_->_request ("cube_long_sequence" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; @@ -714,7 +714,7 @@ DII_Cubit_Client::cube_long_seq_dii (int length) this->call_count_++; - req->invoke (TAO_ENV_SINGLE_ARG_PARAMETER); + req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -822,12 +822,12 @@ DII_Cubit_Client::run (void) if (this->shutdown_) { CORBA::Request_var req (this->obj_var_->_request ("shutdown" - TAO_ENV_ARG_PARAMETER)); + ACE_ENV_ARG_PARAMETER)); ACE_TRY_CHECK; // Cubit::shutdown () is a oneway operation. - req->send_oneway (TAO_ENV_SINGLE_ARG_PARAMETER); + req->send_oneway (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp index 3f9d51cff0b..cd4c2b57d43 100644 --- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp @@ -382,7 +382,7 @@ Cubit_Client::check_enabled (u_int mask) const // Exercise the union. Cube a union. void -Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL) +Cubit_Client::cube_union (ACE_ENV_SINGLE_ARG_DECL) { ACE_TRY { @@ -398,7 +398,7 @@ Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL) ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START); r = this->cubit_->cube_union (u - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -426,7 +426,7 @@ Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL) ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START); r = this->cubit_->cube_union (u - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -459,7 +459,7 @@ Cubit_Client::cube_union (TAO_ENV_SINGLE_ARG_DECL) void Cubit_Client::cube_short (int i - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -471,7 +471,7 @@ Cubit_Client::cube_short (int i ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_SHORT_START); ret_short = cubit_->cube_short (arg_short - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -510,12 +510,12 @@ Cubit_Client::cube_short (int i void Cubit_Client::cube_oneway (int - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ONEWAY_START); - this->cubit_->cube_oneway (TAO_ENV_SINGLE_ARG_PARAMETER); + this->cubit_->cube_oneway (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->call_count_++; } @@ -531,12 +531,12 @@ Cubit_Client::cube_oneway (int void Cubit_Client::cube_void (int - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_VOID_START); - this->cubit_->cube_void (TAO_ENV_SINGLE_ARG_PARAMETER); + this->cubit_->cube_void (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->call_count_++; } @@ -554,7 +554,7 @@ Cubit_Client::cube_void (int void Cubit_Client::cube_octet (int i - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -566,7 +566,7 @@ Cubit_Client::cube_octet (int i ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_START); ret_octet = this->cubit_->cube_octet (arg_octet - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -606,7 +606,7 @@ Cubit_Client::cube_octet (int i void Cubit_Client::cube_long (int i - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -618,7 +618,7 @@ Cubit_Client::cube_long (int i ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_START); ret_long = this->cubit_->cube_long (arg_long - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -661,7 +661,7 @@ Cubit_Client::cube_long (int i void Cubit_Client::cube_struct (int i - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -679,7 +679,7 @@ Cubit_Client::cube_struct (int i ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_STRUCT_START); ret_struct = this->cubit_->cube_struct (arg_struct - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -718,7 +718,7 @@ Cubit_Client::cube_struct (int i void Cubit_Client::cube_long_sequence (int, int l - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -746,7 +746,7 @@ Cubit_Client::cube_long_sequence (int, this->cubit_->cube_long_sequence (input, vout - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -791,7 +791,7 @@ Cubit_Client::cube_long_sequence (int, void Cubit_Client::cube_octet_sequence (int, int l - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -820,7 +820,7 @@ Cubit_Client::cube_octet_sequence (int, this->cubit_->cube_octet_sequence (input, vout - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -866,7 +866,7 @@ Cubit_Client::cube_octet_sequence (int, void Cubit_Client::cube_many_sequence (int, int l - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -902,7 +902,7 @@ Cubit_Client::cube_many_sequence (int, this->cubit_->cube_many_sequence (input, vout - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -951,7 +951,7 @@ void Cubit_Client::cube_rti_data (int, int numUpdates, int numAttrs - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -1022,7 +1022,7 @@ Cubit_Client::cube_rti_data (int, this->cubit_->cube_rti_data (input, vout - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -1054,7 +1054,7 @@ Cubit_Client::cube_rti_data (int, void Cubit_Client::cube_any (int i - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -1069,7 +1069,7 @@ Cubit_Client::cube_any (int i { ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ANY_START); ret_any = this->cubit_->cube_any (arg_any - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -1114,7 +1114,7 @@ Cubit_Client::cube_any (int i void Cubit_Client::cube_any_struct (int i - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_TRY { @@ -1134,7 +1134,7 @@ Cubit_Client::cube_any_struct (int i { ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ANY_STRUCT_START); ret_any = this->cubit_->cube_any_struct (arg_any - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK; @@ -1246,7 +1246,7 @@ Cubit_Client::run () // Show the results one type at a time. - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { // VOID @@ -1259,7 +1259,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_void (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1280,7 +1280,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_short (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1301,7 +1301,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_octet (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1322,7 +1322,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_long (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1342,7 +1342,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_struct (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1362,7 +1362,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { - this->cube_union (TAO_ENV_SINGLE_ARG_PARAMETER); + this->cube_union (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1384,7 +1384,7 @@ Cubit_Client::run () { this->cube_long_sequence (this->loop_count_, 4 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1406,7 +1406,7 @@ Cubit_Client::run () { this->cube_long_sequence (this->loop_count_, 1024 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1433,7 +1433,7 @@ Cubit_Client::run () { this->cube_octet_sequence (this->loop_count_, bytes_in_octet_sequence_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -1443,7 +1443,7 @@ Cubit_Client::run () { this->cube_octet_sequence (this->loop_count_, 16 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -1466,7 +1466,7 @@ Cubit_Client::run () { this->cube_octet_sequence (this->loop_count_, 4096 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1488,7 +1488,7 @@ Cubit_Client::run () { this->cube_many_sequence (this->loop_count_, 4 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1510,7 +1510,7 @@ Cubit_Client::run () { this->cube_many_sequence (this->loop_count_, 1024 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1531,15 +1531,15 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_short (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->cube_octet (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->cube_long (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1561,7 +1561,7 @@ Cubit_Client::run () this->cube_rti_data (this->loop_count_, 2, 5 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1582,7 +1582,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_oneway (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1603,7 +1603,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_any (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1623,7 +1623,7 @@ Cubit_Client::run () for (i = 0; i < this->loop_count_; ++i) { this->cube_any_struct (i - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -1636,7 +1636,7 @@ Cubit_Client::run () } this->shutdown_server (this->shutdown_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -1651,7 +1651,7 @@ Cubit_Client::run () int Cubit_Client::shutdown_server (int do_shutdown - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { if (do_shutdown) { @@ -1660,7 +1660,7 @@ Cubit_Client::shutdown_server (int do_shutdown ACE_TRY_EX(NOT_COLLOCATED) { - this->cubit_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + this->cubit_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (NOT_COLLOCATED); } ACE_CATCHANY @@ -1714,7 +1714,7 @@ Cubit_Client::init (int argc, char **argv) this->orb_ = CORBA::ORB_init (this->argc_, this->argv_, "internet" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse command line and verify parameters. @@ -1744,12 +1744,12 @@ Cubit_Client::init (int argc, char **argv) CORBA::Object_var factory_object = this->orb_->string_to_object (this->cubit_factory_key_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->factory_ = Cubit_Factory::_narrow (factory_object.in() - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->factory_.in ())) @@ -1765,7 +1765,7 @@ Cubit_Client::init (int argc, char **argv) // Now retrieve the Cubit obj ref corresponding to the key. this->cubit_ = - this->factory_->make_cubit (TAO_ENV_SINGLE_ARG_PARAMETER); + this->factory_->make_cubit (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->cubit_.in ())) diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h index 4cddf3da4bd..54d2244eaaa 100644 --- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h @@ -82,59 +82,59 @@ private: ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time); // Prints the time stats. - void cube_union (TAO_ENV_SINGLE_ARG_DECL); + void cube_union (ACE_ENV_SINGLE_ARG_DECL); // Exercise the union. Cube a union. void cube_struct (int i - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // calculate the cube from a struct. void cube_long (int i - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // calculate the cube from a long. void cube_oneway (int i - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Oneway operation test. void cube_void (int i - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Twoway operation test. void cube_octet (int i - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Cube an octet. void cube_short (int i - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Cube a short. void cube_long_sequence (int i, int l - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Cube a sequence <l> is the length of the sequence. void cube_octet_sequence (int i, int l - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Cube a sequence of octets, <l> is the length of the sequence. void cube_many_sequence (int i, int l - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Cube a sequence of manys, <l> is the length of the sequence. void cube_rti_data (int i, int numUpdates, int numAttrs - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Cube a sequence <l> is the length of the sequence. void cube_any_struct (int i - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // calculate the cube from a struct in an any. void cube_any (int i - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // calculate the cube from a long in an any. int shutdown_server (int do_shutdown - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Invoke the method with <do_shutdown> != 0 to shutdown the server. int argc_; diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp index 9e39a72109b..539f14720cb 100644 --- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp @@ -56,14 +56,14 @@ Cubit_Server::parse_args (void) int Cubit_Server::init (int argc, char** argv - TAO_ENV_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER) + ACE_ENV_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER) { // Call the init of <TAO_ORB_Manager> to initialize the ORB and // create a child POA under the root POA. if (this->orb_manager_.init_child_poa (argc, argv, "child_poa" - TAO_ENV_ARG_PARAMETER) == -1) + ACE_ENV_ARG_PARAMETER) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "init_child_poa"), @@ -89,7 +89,7 @@ Cubit_Server::init (int argc, this->factory_id_ = this->orb_manager_.activate_under_child_poa ("factory", this->factory_impl_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -108,9 +108,9 @@ Cubit_Server::init (int argc, } int -Cubit_Server::run (TAO_ENV_SINGLE_ARG_DECL) +Cubit_Server::run (ACE_ENV_SINGLE_ARG_DECL) { - if (this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER) == -1) + if (this->orb_manager_.run (ACE_ENV_SINGLE_ARG_PARAMETER) == -1) ACE_ERROR_RETURN ((LM_ERROR, "Cubit_Server::run"), -1); diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h index d31269dd6ee..5f5bb1419d4 100644 --- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h @@ -52,10 +52,10 @@ public: int init (int argc, char **argv - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Initialize the Cubit_Server state - parsing arguments and ... - int run (TAO_ENV_SINGLE_ARG_DECL); + int run (ACE_ENV_SINGLE_ARG_DECL); // Run the orb private: diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp index 6eca9eb5f98..d3c6cc45515 100644 --- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp @@ -126,10 +126,10 @@ Cubit_Factory_i::~Cubit_Factory_i (void) } Cubit_ptr -Cubit_Factory_i::make_cubit (TAO_ENV_SINGLE_ARG_DECL) +Cubit_Factory_i::make_cubit (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - return my_cubit_._this (TAO_ENV_SINGLE_ARG_PARAMETER); + return my_cubit_._this (ACE_ENV_SINGLE_ARG_PARAMETER); } void @@ -152,7 +152,7 @@ Cubit_i::~Cubit_i (void) } PortableServer::POA_ptr -Cubit_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Cubit_i::_default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } @@ -164,14 +164,14 @@ Cubit_i::set_default_poa (PortableServer::POA_ptr poa) } void -Cubit_i::cube_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Cubit_i::cube_oneway (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ONEWAY_START); } void -Cubit_i::cube_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Cubit_i::cube_void (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_VOID_START); @@ -181,7 +181,7 @@ Cubit_i::cube_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) CORBA::Octet Cubit_i::cube_octet (CORBA::Octet o - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_OCTET_START); @@ -193,7 +193,7 @@ Cubit_i::cube_octet (CORBA::Octet o CORBA::Short Cubit_i::cube_short (CORBA::Short s - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_SHORT_START); @@ -205,7 +205,7 @@ Cubit_i::cube_short (CORBA::Short s CORBA::Long Cubit_i::cube_long (CORBA::Long l - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_START); @@ -217,7 +217,7 @@ Cubit_i::cube_long (CORBA::Long l Cubit::Many Cubit_i::cube_struct (const Cubit::Many &values - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_STRUCT_START); @@ -235,7 +235,7 @@ Cubit_i::cube_struct (const Cubit::Many &values Cubit::oneof Cubit_i::cube_union (const Cubit::oneof &values - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_UNION_START); @@ -269,7 +269,7 @@ Cubit_i::cube_union (const Cubit::oneof &values void Cubit_i::cube_long_sequence (const Cubit::long_seq &input, Cubit::long_seq_out output - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_SEQUENCE_START); @@ -296,7 +296,7 @@ Cubit_i::cube_long_sequence (const Cubit::long_seq &input, void Cubit_i::cube_octet_sequence (const Cubit::octet_seq &input, Cubit::octet_seq_out output - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_OCTET_SEQUENCE_START); @@ -337,7 +337,7 @@ Cubit_i::cube_octet_sequence (const Cubit::octet_seq &input, void Cubit_i::cube_many_sequence (const Cubit::many_seq & input, Cubit::many_seq_out output - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_MANY_SEQUENCE_START); @@ -371,7 +371,7 @@ Cubit_i::cube_many_sequence (const Cubit::many_seq & input, void Cubit_i::cube_rti_data (const Cubit::RtiPacket &input, Cubit::RtiPacket_out output - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_SEQUENCE_START); @@ -403,7 +403,7 @@ Cubit_i::cube_rti_data (const Cubit::RtiPacket &input, CORBA::Any * Cubit_i::cube_any (const CORBA::Any & any - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ANY_START); @@ -420,7 +420,7 @@ Cubit_i::cube_any (const CORBA::Any & any CORBA::Any * Cubit_i::cube_any_struct (const CORBA::Any & any - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ANY_STRUCT_START); @@ -439,7 +439,7 @@ Cubit_i::cube_any_struct (const CORBA::Any & any // Shutdown. -void Cubit_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +void Cubit_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h index 454be029601..517bd50068c 100644 --- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h @@ -37,77 +37,77 @@ public: ~Cubit_i (void); // Destructor - virtual PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + virtual PortableServer::POA_ptr _default_POA (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); // Returns the default POA for this servant. - virtual void cube_oneway (TAO_ENV_SINGLE_ARG_DECL) + virtual void cube_oneway (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Test a oneway call. - virtual void cube_void (TAO_ENV_SINGLE_ARG_DECL) + virtual void cube_void (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Test a twoway call. virtual CORBA::Octet cube_octet (CORBA::Octet o - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube an octet virtual CORBA::Short cube_short (CORBA::Short s - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube a short virtual CORBA::Long cube_long (CORBA::Long l - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube a long virtual Cubit::Many cube_struct (const Cubit::Many &values - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube a struct. virtual Cubit::oneof cube_union (const Cubit::oneof &values - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube a union. virtual void cube_long_sequence (const Cubit::long_seq &input, Cubit::long_seq_out output - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube a sequence. virtual void cube_octet_sequence (const Cubit::octet_seq &input, Cubit::octet_seq_out output - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube an octet sequence. virtual void cube_many_sequence (const Cubit::many_seq & input, Cubit::many_seq_out output - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube an Many sequence. virtual void cube_rti_data (const Cubit::RtiPacket &input, Cubit::RtiPacket_out output - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube a sequence. virtual CORBA::Any * cube_any (const CORBA::Any & any - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube a long in an any virtual CORBA::Any * cube_any_struct (const CORBA::Any & any - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Cube a struct in an any - virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Shutdown routine. @@ -135,7 +135,7 @@ public: ~Cubit_Factory_i (void); // Destructor. - virtual Cubit_ptr make_cubit (TAO_ENV_SINGLE_ARG_DECL) + virtual Cubit_ptr make_cubit (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Make a cubit object. diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp index b988891d80a..aef78ddc350 100644 --- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp @@ -44,14 +44,14 @@ svr_worker (void *arg) { int result = cubit_server.init (args.argc (), args.argv () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result == -1) return (void *) 1; barrier->server_init_.wait (); - cubit_server.run (TAO_ENV_SINGLE_ARG_PARAMETER); + cubit_server.run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; barrier->client_fini_.wait (); diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp index af690c0ace4..b32c03b6451 100644 --- a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp @@ -46,13 +46,13 @@ main (int argc, char *argv[]) "\n\tIDL_Cubit: server\n\n")); ACE_TRY_NEW_ENV { - int ret = cubit_server.init (argc, argv TAO_ENV_ARG_PARAMETER); + int ret = cubit_server.init (argc, argv ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (ret == -1) return -1; - cubit_server.run (TAO_ENV_SINGLE_ARG_PARAMETER); + cubit_server.run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_OS::sleep (5); diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp index 1105a5a099c..25363f792a3 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Cubit_Task.cpp @@ -64,14 +64,14 @@ Cubit_Task::svc (void) "Create Servants failed.\n"), -1); - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { GLOBALS::instance ()->barrier_->wait (); // Handle requests for this object until we're killed, or one of // the methods asks us to exit. - int r = this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER); + int r = this->orb_manager_.run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (r == -1) @@ -84,7 +84,7 @@ Cubit_Task::svc (void) CORBA::ORB_var orb = this->orb_manager_.orb (); - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -105,7 +105,7 @@ Cubit_Task::svc (void) int Cubit_Task::initialize_orb (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { ACE_ARGV args (this->orbargs_); @@ -122,7 +122,7 @@ Cubit_Task::initialize_orb (void) argv, "persistent_poa", orb_name - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r == -1) return -1; @@ -166,23 +166,23 @@ Cubit_Task::get_servant_ior (u_int index) int Cubit_Task::create_servants (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { CORBA::Object_var obj = this->orb_->resolve_initial_references ("RootPOA" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var poa = - PortableServer::POA::_narrow (obj.in () TAO_ENV_ARG_PARAMETER); + PortableServer::POA::_narrow (obj.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var manager = - poa->the_POAManager(TAO_ENV_SINGLE_ARG_PARAMETER); + poa->the_POAManager(ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - manager->activate(TAO_ENV_SINGLE_ARG_PARAMETER); + manager->activate(ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Create the array of cubit implementations. @@ -232,13 +232,13 @@ Cubit_Task::create_servants (void) // some client. Then release the object. Cubit_var cubit = - this->servants_[i]->_this (TAO_ENV_SINGLE_ARG_PARAMETER); + this->servants_[i]->_this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var str = this->orb_->object_to_string (cubit.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->servants_iors_[i] = diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp index 824d3dbcabc..da15b9ad9b3 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.cpp @@ -553,7 +553,7 @@ Client::find_frequency (void) } CORBA::ORB_ptr -Client::init_orb (TAO_ENV_SINGLE_ARG_DECL) +Client::init_orb (ACE_ENV_SINGLE_ARG_DECL) { ACE_DEBUG ((LM_DEBUG, "I'm thread %t\n")); @@ -583,7 +583,7 @@ Client::init_orb (TAO_ENV_SINGLE_ARG_DECL) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, orbid - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (CORBA::ORB::_nil ()); if (this->id_ == 0) @@ -613,7 +613,7 @@ Client::init_orb (TAO_ENV_SINGLE_ARG_DECL) } int -Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL) +Client::get_cubit (CORBA::ORB_ptr orb ACE_ENV_ARG_DECL) { char *my_ior = this->ts_->use_utilization_test_ == 1 @@ -633,7 +633,7 @@ Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL) CORBA::Object_var objref = orb->string_to_object (my_ior - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (CORBA::is_nil (objref.in ())) @@ -644,7 +644,7 @@ Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL) // Narrow the CORBA::Object reference to the stub object, // checking the type along the way using _is_a. this->cubit_ = Cubit::_narrow (objref.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); if (CORBA::is_nil (this->cubit_)) @@ -657,7 +657,7 @@ Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL) CORBA::String_var str = orb->object_to_string (this->cubit_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -670,18 +670,18 @@ Client::get_cubit (CORBA::ORB_ptr orb TAO_ENV_ARG_DECL) int Client::svc (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { // Initialize the ORB. - CORBA::ORB_var orb = this->init_orb (TAO_ENV_SINGLE_ARG_PARAMETER); + CORBA::ORB_var orb = this->init_orb (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Find the frequency of CORBA requests based on thread id. this->find_frequency (); // Get the cubit object from the file. - int r = this->get_cubit (orb.in () TAO_ENV_ARG_PARAMETER); + int r = this->get_cubit (orb.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r != 0) return r; @@ -716,14 +716,14 @@ Client::svc (void) { ACE_DEBUG ((LM_DEBUG, "(%t) CALLING SHUTDOWN() ON THE SERVANT\n")); - this->cubit_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + this->cubit_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } CORBA::release (this->cubit_); this->cubit_ = 0; - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY @@ -746,7 +746,7 @@ Client::svc (void) int Client::cube_octet (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { this->call_count_++; @@ -758,10 +758,10 @@ Client::cube_octet (void) if (this->ts_->use_utilization_test_ == 1 && this->ts_->remote_invocations_ == 0) ret_octet = this->cubit_impl_.cube_octet (arg_octet - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); else ret_octet = this->cubit_->cube_octet (arg_octet - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); STOP_QUANTIFY; ACE_TRY_CHECK; @@ -792,7 +792,7 @@ Client::cube_octet (void) int Client::cube_short (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { this->call_count_++; @@ -802,7 +802,7 @@ Client::cube_short (void) START_QUANTIFY; ret_short = this->cubit_->cube_short (arg_short - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); STOP_QUANTIFY; ACE_TRY_CHECK; arg_short = arg_short * arg_short * arg_short; @@ -829,7 +829,7 @@ Client::cube_short (void) int Client::cube_long (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { this->call_count_++; @@ -839,7 +839,7 @@ Client::cube_long (void) START_QUANTIFY; ret_long = this->cubit_->cube_long (arg_long - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); STOP_QUANTIFY; ACE_TRY_CHECK; @@ -866,7 +866,7 @@ Client::cube_long (void) int Client::cube_struct (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { Cubit::Many arg_struct; @@ -880,7 +880,7 @@ Client::cube_struct (void) START_QUANTIFY; ret_struct = this->cubit_->cube_struct (arg_struct - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); STOP_QUANTIFY; ACE_TRY_CHECK; @@ -940,12 +940,12 @@ Client::make_request (void) } else { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { this->call_count_++; START_QUANTIFY; - this->cubit_->noop (TAO_ENV_SINGLE_ARG_PARAMETER); + this->cubit_->noop (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; STOP_QUANTIFY; } diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h index 554ad87b619..cd169ebe4d0 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/Task_Client.h @@ -279,14 +279,14 @@ public: // cubed. private: - CORBA::ORB_ptr init_orb (TAO_ENV_SINGLE_ARG_DECL); + CORBA::ORB_ptr init_orb (ACE_ENV_SINGLE_ARG_DECL); // initialize the ORB. void read_ior (void); // reads the cubit ior from a file. int get_cubit (CORBA::ORB_ptr orb - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // gets the cubit object. int run_tests (void); diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp index 8de8568c427..0dbd9106a87 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.cpp @@ -19,7 +19,7 @@ Cubit_i::~Cubit_i (void) CORBA::Octet Cubit_i::cube_octet (CORBA::Octet o - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return (CORBA::Octet) (o * o * o); @@ -27,7 +27,7 @@ Cubit_i::cube_octet (CORBA::Octet o CORBA::Short Cubit_i::cube_short (CORBA::Short s - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return (CORBA::Short) (s * s * s); @@ -35,7 +35,7 @@ Cubit_i::cube_short (CORBA::Short s CORBA::Long Cubit_i::cube_long (CORBA::Long l - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { return (CORBA::Long) (l * l * l); @@ -43,7 +43,7 @@ Cubit_i::cube_long (CORBA::Long l Cubit::Many Cubit_i::cube_struct (const Cubit::Many &values - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { Cubit::Many out_values; @@ -56,13 +56,13 @@ Cubit_i::cube_struct (const Cubit::Many &values } void -Cubit_i::noop (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Cubit_i::noop (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { // does nothing. } -void Cubit_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +void Cubit_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, @@ -71,7 +71,7 @@ void Cubit_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) } PortableServer::POA_ptr -Cubit_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Cubit_i::_default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h index bc65208821d..eaa646cfb06 100644 --- a/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/cubit_i.h @@ -30,29 +30,29 @@ public: ~Cubit_i (void); virtual CORBA::Octet cube_octet (CORBA::Octet o - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual CORBA::Short cube_short (CORBA::Short s - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual CORBA::Long cube_long (CORBA::Long l - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual Cubit::Many cube_struct (const Cubit::Many &values - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void noop (TAO_ENV_SINGLE_ARG_DECL) + virtual void noop (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); virtual PortableServer::POA_ptr - _default_POA (TAO_ENV_SINGLE_ARG_DECL); + _default_POA (ACE_ENV_SINGLE_ARG_DECL); // The default POA protected: diff --git a/TAO/performance-tests/DII_Latency/Roundtrip.cpp b/TAO/performance-tests/DII_Latency/Roundtrip.cpp new file mode 100644 index 00000000000..df15cd65d8a --- /dev/null +++ b/TAO/performance-tests/DII_Latency/Roundtrip.cpp @@ -0,0 +1,26 @@ +// +// $Id$ +// +#include "Roundtrip.h" + +ACE_RCSID(DII_Latency, Roundtrip, "$Id$") + +Roundtrip::Roundtrip (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +Test::Timestamp +Roundtrip::test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return send_time; +} + +void +Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} diff --git a/TAO/performance-tests/DII_Latency/Roundtrip.h b/TAO/performance-tests/DII_Latency/Roundtrip.h new file mode 100644 index 00000000000..efef33dd7e6 --- /dev/null +++ b/TAO/performance-tests/DII_Latency/Roundtrip.h @@ -0,0 +1,46 @@ +// +// $Id$ +// + +#ifndef ROUNDTRIP_H +#define ROUNDTRIP_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::Roundtrip interface +class Roundtrip + : public virtual POA_Test::Roundtrip + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Roundtrip (CORBA::ORB_ptr orb); + + // = The skeleton methods + virtual Test::Timestamp test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ROUNDTRIP_H */ diff --git a/TAO/performance-tests/DII_Latency/client.cpp b/TAO/performance-tests/DII_Latency/client.cpp new file mode 100644 index 00000000000..57935526269 --- /dev/null +++ b/TAO/performance-tests/DII_Latency/client.cpp @@ -0,0 +1,178 @@ +// $Id$ + +#include "ace/Get_Opt.h" +#include "ace/High_Res_Timer.h" +#include "ace/Sched_Params.h" +#include "ace/Stats.h" +#include "ace/Sample_History.h" + +#include "tao/Strategies/advanced_resource.h" +#include "tao/DynamicInterface/Request.h" + +ACE_RCSID(DII_Latency, client, "$Id$") + +const char *ior = "file://test.ior"; +int niterations = 100; +int do_dump_history = 0; +int do_shutdown = 1; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "hxk:i:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'h': + do_dump_history = 1; + break; + + case 'x': + do_shutdown = 0; + break; + + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "-i <niterations> " + "-x (disable shutdown) " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "client (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "client (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (object.in ())) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Nil CORBA::Object reference <%s>\n", + ior), + 1); + } + + for (int j = 0; j < 100; ++j) + { + CORBA::Request_var request = + object->_request ("test_method" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::ULongLong dummy = 0; + request->add_in_arg("send_time") <<= dummy; + + request->set_return_type (CORBA::_tc_ulonglong); + request->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + ACE_Sample_History history (niterations); + + ACE_hrtime_t test_start = ACE_OS::gethrtime (); + for (int i = 0; i < niterations; ++i) + { + CORBA::ULongLong start = ACE_OS::gethrtime (); + + CORBA::Request_var request = + object->_request ("test_method" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + request->add_in_arg("send_time") <<= start; + + request->set_return_type (CORBA::_tc_ulonglong); + request->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_hrtime_t now = ACE_OS::gethrtime (); + history.sample (now - start); + } + + ACE_hrtime_t test_end = ACE_OS::gethrtime (); + + ACE_DEBUG ((LM_DEBUG, "test finished\n")); + + ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration....")); + ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); + ACE_DEBUG ((LM_DEBUG, "done\n")); + + if (do_dump_history) + { + history.dump_samples ("HISTORY", gsf); + } + + ACE_Basic_Stats stats; + history.collect_basic_stats (stats); + stats.dump_results ("Total", gsf); + + ACE_Throughput_Stats::dump_throughput ("Total", gsf, + test_end - test_start, + stats.samples_count ()); + + if (do_shutdown) + { + CORBA::Request_var request = + object->_request ("shutdown" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + request->invoke (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/DII_Latency/server.cpp b/TAO/performance-tests/DII_Latency/server.cpp new file mode 100644 index 00000000000..e96f0ff595a --- /dev/null +++ b/TAO/performance-tests/DII_Latency/server.cpp @@ -0,0 +1,136 @@ +// $Id$ + +#include "Roundtrip.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(Single_Threaded_Latency, 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.opt_arg (); + 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[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority); + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "server (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "server (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + 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_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Roundtrip *roundtrip_impl; + ACE_NEW_RETURN (roundtrip_impl, + Roundtrip (orb.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(roundtrip_impl); + + Test::Roundtrip_var roundtrip = + roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER); + 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_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/DSI_Latency/Roundtrip.cpp b/TAO/performance-tests/DSI_Latency/Roundtrip.cpp new file mode 100644 index 00000000000..6de5cfe047a --- /dev/null +++ b/TAO/performance-tests/DSI_Latency/Roundtrip.cpp @@ -0,0 +1,97 @@ +// +// $Id$ +// +#include "Roundtrip.h" +#include "tao/DynamicInterface/Server_Request.h" + +ACE_RCSID(Single_Threaded_Latency, Roundtrip, "$Id$") + +Roundtrip::Roundtrip (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +void +Roundtrip::invoke (CORBA::ServerRequest_ptr request + ACE_ENV_ARG_DECL) +{ + if (ACE_OS::strcmp ("shutdown", request->operation ()) == 0) + { + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + return; + } + + else if (ACE_OS::strcmp ("_is_a", request->operation ()) == 0) + { + CORBA::NVList_ptr list; + this->orb_->create_list (0, list ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Any type_id (CORBA::_tc_string); + list->add_value ("type_id", type_id, CORBA::ARG_IN + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + request->arguments (list ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::NamedValue_ptr nv = list->item (0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + const char *arg; + *(nv->value ()) >>= arg; + + CORBA::Boolean type_matches = 0; + if (ACE_OS::strcmp (arg, "IDL:Test/Roundtrip:1.0") == 0 + || ACE_OS::strcmp (arg, "IDL:omg.org/CORBA/Object:1.0") == 0 + || ACE_OS::strcmp (arg, "") == 0) + type_matches = 1; + + CORBA::Any result; + result <<= CORBA::Any::from_boolean (type_matches); + + request->set_result (result ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + return; + } + + else if (ACE_OS::strcmp ("test_method", request->operation ()) == 0) + { + CORBA::NVList_ptr list; + this->orb_->create_list (0, list ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::Any send_time (CORBA::_tc_ulonglong); + list->add_value ("send_time", send_time, CORBA::ARG_IN + ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + request->arguments (list ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + CORBA::NamedValue_ptr nv = list->item (0 ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + request->set_result (*(nv->value ()) ACE_ENV_ARG_PARAMETER); + ACE_CHECK; + + return; + } + + CORBA::Any bad_operation; + CORBA::BAD_OPERATION exception; + bad_operation <<= exception; + request->set_exception (bad_operation ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +CORBA::RepositoryId +Roundtrip::_primary_interface (const PortableServer::ObjectId &, + PortableServer::POA_ptr + ACE_ENV_ARG_DECL_NOT_USED) +{ + return CORBA::string_dup ("IDL:Test/Roundtrip:1.0"); +} diff --git a/TAO/performance-tests/DSI_Latency/Roundtrip.h b/TAO/performance-tests/DSI_Latency/Roundtrip.h new file mode 100644 index 00000000000..d795dcb56f1 --- /dev/null +++ b/TAO/performance-tests/DSI_Latency/Roundtrip.h @@ -0,0 +1,48 @@ +// +// $Id$ +// + +#ifndef ROUNDTRIP_H +#define ROUNDTRIP_H +#include "ace/pre.h" + +#include "tao/DynamicInterface/Dynamic_Implementation.h" +#include "tao/PortableServer/PortableServer.h" +#include "tao/corba.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::Roundtrip interface +class Roundtrip + : public virtual PortableServer::DynamicImplementation + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Roundtrip (CORBA::ORB_ptr orb); + + // = The DSI methods + virtual void invoke (CORBA::ServerRequest_ptr request + ACE_ENV_ARG_DECL); + virtual CORBA::RepositoryId _primary_interface ( + const PortableServer::ObjectId &oid, + PortableServer::POA_ptr poa + ACE_ENV_ARG_DECL); + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ROUNDTRIP_H */ diff --git a/TAO/performance-tests/DSI_Latency/client.cpp b/TAO/performance-tests/DSI_Latency/client.cpp new file mode 100644 index 00000000000..2a264e91b43 --- /dev/null +++ b/TAO/performance-tests/DSI_Latency/client.cpp @@ -0,0 +1,163 @@ +// $Id$ + +#include "TestC.h" +#include "ace/Get_Opt.h" +#include "ace/High_Res_Timer.h" +#include "ace/Sched_Params.h" +#include "ace/Stats.h" +#include "ace/Sample_History.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(DSI_Latency, client, "$Id$") + +const char *ior = "file://test.ior"; +int niterations = 100; +int do_dump_history = 0; +int do_shutdown = 1; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "hxk:i:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'h': + do_dump_history = 1; + break; + + case 'x': + do_shutdown = 0; + break; + + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "-i <niterations> " + "-x (disable shutdown) " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "client (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "client (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Test::Roundtrip_var roundtrip = + Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (roundtrip.in ())) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Nil Test::Roundtrip reference <%s>\n", + ior), + 1); + } + + for (int j = 0; j < 100; ++j) + { + ACE_hrtime_t start = 0; + (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + ACE_Sample_History history (niterations); + + ACE_hrtime_t test_start = ACE_OS::gethrtime (); + for (int i = 0; i < niterations; ++i) + { + ACE_hrtime_t start = ACE_OS::gethrtime (); + + (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_hrtime_t now = ACE_OS::gethrtime (); + history.sample (now - start); + } + + ACE_hrtime_t test_end = ACE_OS::gethrtime (); + + ACE_DEBUG ((LM_DEBUG, "test finished\n")); + + ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration....")); + ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); + ACE_DEBUG ((LM_DEBUG, "done\n")); + + if (do_dump_history) + { + history.dump_samples ("HISTORY", gsf); + } + + ACE_Basic_Stats stats; + history.collect_basic_stats (stats); + stats.dump_results ("Total", gsf); + + ACE_Throughput_Stats::dump_throughput ("Total", gsf, + test_end - test_start, + stats.samples_count ()); + + if (do_shutdown) + { + roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/DSI_Latency/server.cpp b/TAO/performance-tests/DSI_Latency/server.cpp new file mode 100644 index 00000000000..ebc70ade1d7 --- /dev/null +++ b/TAO/performance-tests/DSI_Latency/server.cpp @@ -0,0 +1,142 @@ +// $Id$ + +#include "Roundtrip.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(DSI_Latency, 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.opt_arg (); + 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[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority); + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "server (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "server (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + 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_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Roundtrip *roundtrip_impl; + ACE_NEW_RETURN (roundtrip_impl, + Roundtrip (orb.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(roundtrip_impl); + + PortableServer::ObjectId_var oid = + root_poa->activate_object (roundtrip_impl + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var roundtrip = + root_poa->id_to_reference (oid.in () + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER); + 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_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Deferred_Latency/Roundtrip.cpp b/TAO/performance-tests/Deferred_Latency/Roundtrip.cpp new file mode 100644 index 00000000000..72f83576b44 --- /dev/null +++ b/TAO/performance-tests/Deferred_Latency/Roundtrip.cpp @@ -0,0 +1,26 @@ +// +// $Id$ +// +#include "Roundtrip.h" + +ACE_RCSID(Single_Threaded_Latency, Roundtrip, "$Id$") + +Roundtrip::Roundtrip (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +Test::Timestamp +Roundtrip::test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return send_time; +} + +void +Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} diff --git a/TAO/performance-tests/Deferred_Latency/Roundtrip.h b/TAO/performance-tests/Deferred_Latency/Roundtrip.h new file mode 100644 index 00000000000..efef33dd7e6 --- /dev/null +++ b/TAO/performance-tests/Deferred_Latency/Roundtrip.h @@ -0,0 +1,46 @@ +// +// $Id$ +// + +#ifndef ROUNDTRIP_H +#define ROUNDTRIP_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::Roundtrip interface +class Roundtrip + : public virtual POA_Test::Roundtrip + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Roundtrip (CORBA::ORB_ptr orb); + + // = The skeleton methods + virtual Test::Timestamp test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ROUNDTRIP_H */ diff --git a/TAO/performance-tests/Deferred_Latency/client.cpp b/TAO/performance-tests/Deferred_Latency/client.cpp new file mode 100644 index 00000000000..8aa94d94172 --- /dev/null +++ b/TAO/performance-tests/Deferred_Latency/client.cpp @@ -0,0 +1,203 @@ +// $Id$ + +#include "TestC.h" + +#include "tao/DynamicInterface/Request.h" + +#include "tao/Strategies/advanced_resource.h" + +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" +#include "ace/High_Res_Timer.h" +#include "ace/Sched_Params.h" +#include "ace/Stats.h" +#include "ace/Sample_History.h" + +ACE_RCSID(Deferred_Latency, client, "$Id$") + +const char *ior = "file://test.ior"; +int niterations = 1000; +int burst = 10; +int do_shutdown = 1; +int do_dump_history = 0; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "hxk:i:b:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'h': + do_dump_history = 1; + break; + + case 'x': + do_shutdown = 0; + break; + + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case 'b': + burst = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "-i <niterations> " + "-b <burst> " + "-x (disable shutdown) " + "-h (dump history) " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "client (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "client (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Test::Roundtrip_var roundtrip = + Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (roundtrip.in ())) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Nil Test::Roundtrip reference <%s>\n", + ior), + 1); + } + + for (int j = 0; j < 100; ++j) + { + ACE_hrtime_t start = 0; + (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + ACE_Sample_History history (niterations); + + ACE_hrtime_t test_start = ACE_OS::gethrtime (); + + CORBA::Request_var *request; + ACE_NEW_RETURN (request, CORBA::Request_var[burst], 1); + + for (int i = 0; i < niterations; ++i) + { + int j; + + for (j = 0; j != burst; ++j) + { + CORBA::ULongLong start = ACE_OS::gethrtime (); + + request[j] = + roundtrip->_request ("test_method" + ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + request[j]->add_in_arg () <<= start; + request[j]->set_return_type (CORBA::_tc_ulonglong); + + request[j]->send_deferred (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + for (j = 0; j != burst; ++j) + { + request[j]->get_response (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::ULongLong retval; + if ((request[j]->return_value () >>= retval) == 1) + { + ACE_hrtime_t now = ACE_OS::gethrtime (); + history.sample (now - retval); + } + } + } + delete[] request; + + ACE_hrtime_t test_end = ACE_OS::gethrtime (); + + ACE_DEBUG ((LM_DEBUG, "test finished\n")); + + ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration....")); + ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); + ACE_DEBUG ((LM_DEBUG, "done\n")); + + if (do_dump_history) + { + history.dump_samples ("HISTORY", gsf); + } + + ACE_Basic_Stats stats; + history.collect_basic_stats (stats); + stats.dump_results ("Total", gsf); + + ACE_Throughput_Stats::dump_throughput ("Total", gsf, + test_end - test_start, + stats.samples_count ()); + + if (do_shutdown) + { + roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, + "Caught exception:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Deferred_Latency/server.cpp b/TAO/performance-tests/Deferred_Latency/server.cpp new file mode 100644 index 00000000000..e96f0ff595a --- /dev/null +++ b/TAO/performance-tests/Deferred_Latency/server.cpp @@ -0,0 +1,136 @@ +// $Id$ + +#include "Roundtrip.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(Single_Threaded_Latency, 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.opt_arg (); + 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[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority); + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "server (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "server (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + 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_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Roundtrip *roundtrip_impl; + ACE_NEW_RETURN (roundtrip_impl, + Roundtrip (orb.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(roundtrip_impl); + + Test::Roundtrip_var roundtrip = + roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER); + 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_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/POA/Create_Reference/create_reference.cpp b/TAO/performance-tests/POA/Create_Reference/create_reference.cpp index 286b7d6282c..e26b101e25e 100644 --- a/TAO/performance-tests/POA/Create_Reference/create_reference.cpp +++ b/TAO/performance-tests/POA/Create_Reference/create_reference.cpp @@ -75,7 +75,7 @@ set_rt_scheduling (void) void object_creation_test (PortableServer::POA_ptr poa, int create_reference_with_id - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { ACE_DEBUG ((LM_DEBUG, "\nCreating %d object references with %s\n", @@ -102,14 +102,14 @@ object_creation_test (PortableServer::POA_ptr poa, object = poa->create_reference_with_id (oid.in (), "IDL:Test/Simple:1.0" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; } else { object = poa->create_reference ("IDL:Test/Simple:1.0" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -136,12 +136,12 @@ main (int argc, char *argv[]) { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, "" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -151,14 +151,14 @@ main (int argc, char *argv[]) PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -168,32 +168,32 @@ main (int argc, char *argv[]) policies[0] = root_poa->create_id_assignment_policy (PortableServer::USER_ID - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var child_poa = root_poa->create_POA ("TestPOA", poa_manager.in (), policies - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; gsf = ACE_High_Res_Timer::global_scale_factor (); object_creation_test (root_poa.in (), 0 // POA::create_reference - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object_creation_test (child_poa.in (), 1 // POA::create_reference_with_id - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/performance-tests/POA/Demux/client.cpp b/TAO/performance-tests/POA/Demux/client.cpp index 22f2bd9048f..9a013dadf0b 100644 --- a/TAO/performance-tests/POA/Demux/client.cpp +++ b/TAO/performance-tests/POA/Demux/client.cpp @@ -34,12 +34,12 @@ main (int argc, char *argv []) ACE_TRY_NEW_ENV; { int r = demux_test_client.init (argc, argv - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r == -1) return -1; - demux_test_client.run (TAO_ENV_SINGLE_ARG_PARAMETER); + demux_test_client.run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::SystemException, sysex) diff --git a/TAO/performance-tests/POA/Demux/demux_test_client.cpp b/TAO/performance-tests/POA/Demux/demux_test_client.cpp index a11e1675aea..5ff3035ce57 100644 --- a/TAO/performance-tests/POA/Demux/demux_test_client.cpp +++ b/TAO/performance-tests/POA/Demux/demux_test_client.cpp @@ -45,7 +45,7 @@ Demux_Test_Client::~Demux_Test_Client (void) int Demux_Test_Client::init (int argc, char *argv [] - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { this->argc_ = argc; this->argv_ = argv; @@ -55,7 +55,7 @@ Demux_Test_Client::init (int argc, char *argv [] { // get the underlying ORB this->orb_ = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (GET_ORB); } ACE_CATCHANY @@ -102,13 +102,13 @@ Demux_Test_Client::init (int argc, char *argv [] ACE_TRY_EX (IOR) { CORBA::Object_var objref = this->orb_->string_to_object (str - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (IOR); // now narrow to Demux_Test object this->demux_test_[i][j] = Demux_Test::_narrow (objref.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (IOR); @@ -252,7 +252,7 @@ Demux_Test_Client::parse_args (void) // The main program for Demux_Test int -Demux_Test_Client::run (TAO_ENV_SINGLE_ARG_DECL) +Demux_Test_Client::run (ACE_ENV_SINGLE_ARG_DECL) { // open a temporary results file if ((this->result_fp_ = ACE_OS::fopen ("results.dat", "w")) == 0) @@ -267,19 +267,19 @@ Demux_Test_Client::run (TAO_ENV_SINGLE_ARG_DECL) switch (this->is_) { case Demux_Test_Client::LINEAR: - (void) this->run_linear_test (TAO_ENV_SINGLE_ARG_PARAMETER); + (void) this->run_linear_test (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (RUN); break; case Demux_Test_Client::RANDOM: - (void) this->run_random_test (TAO_ENV_SINGLE_ARG_PARAMETER); + (void) this->run_random_test (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (RUN); break; case Demux_Test_Client::BEST: - (void) this->run_best_test (TAO_ENV_SINGLE_ARG_PARAMETER); + (void) this->run_best_test (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (RUN); break; case Demux_Test_Client::WORST: - (void) this->run_worst_test (TAO_ENV_SINGLE_ARG_PARAMETER); + (void) this->run_worst_test (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (RUN); break; } @@ -301,7 +301,7 @@ Demux_Test_Client::run (TAO_ENV_SINGLE_ARG_DECL) ACE_TRY_EX (SHUTDOWN) { // call the shutdown method one the first object - this->demux_test_[0][0]->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + this->demux_test_[0][0]->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (SHUTDOWN); } ACE_CATCHANY @@ -329,7 +329,7 @@ Demux_Test_Client::run (TAO_ENV_SINGLE_ARG_DECL) } int -Demux_Test_Client::run_linear_test (TAO_ENV_SINGLE_ARG_DECL) +Demux_Test_Client::run_linear_test (ACE_ENV_SINGLE_ARG_DECL) { CORBA::ULong j, k, l, m; ACE_hrtime_t start, end; @@ -342,7 +342,7 @@ Demux_Test_Client::run_linear_test (TAO_ENV_SINGLE_ARG_DECL) start = ACE_OS::gethrtime (); // invoke the method - this->op_db_[l].op_ (this->demux_test_[j][k].in () TAO_ENV_ARG_PARAMETER); + this->op_db_[l].op_ (this->demux_test_[j][k].in () ACE_ENV_ARG_PARAMETER); end = ACE_OS::gethrtime (); @@ -355,7 +355,7 @@ Demux_Test_Client::run_linear_test (TAO_ENV_SINGLE_ARG_DECL) } int -Demux_Test_Client::run_random_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Demux_Test_Client::run_random_test (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) { ACE_DEBUG ((LM_DEBUG, "ERROR : Random test\n")); @@ -363,7 +363,7 @@ Demux_Test_Client::run_random_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) } int -Demux_Test_Client::run_best_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Demux_Test_Client::run_best_test (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) { ACE_DEBUG ((LM_DEBUG, "ERROR : Best Test\n")); @@ -371,7 +371,7 @@ Demux_Test_Client::run_best_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) } int -Demux_Test_Client::run_worst_test (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +Demux_Test_Client::run_worst_test (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) { ACE_DEBUG ((LM_DEBUG, "ERROR : Worst test\n")); diff --git a/TAO/performance-tests/POA/Demux/demux_test_client.h b/TAO/performance-tests/POA/Demux/demux_test_client.h index a6ed4afce27..7b0a3714f32 100644 --- a/TAO/performance-tests/POA/Demux/demux_test_client.h +++ b/TAO/performance-tests/POA/Demux/demux_test_client.h @@ -38,7 +38,7 @@ public: WORST }; - typedef void (*OP_PTR) (Demux_Test_ptr TAO_ENV_ARG_DECL_NOT_USED); + typedef void (*OP_PTR) (Demux_Test_ptr ACE_ENV_ARG_DECL_NOT_USED); struct Operation_DB_Entry { @@ -51,10 +51,10 @@ public: ~Demux_Test_Client (void); // DTOR - int init (int argc, char *argv [] TAO_ENV_ARG_DECL_WITH_DEFAULTS); + int init (int argc, char *argv [] ACE_ENV_ARG_DECL_WITH_DEFAULTS); // initialize the client test bed - int run (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + int run (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); // run the tests private: @@ -65,16 +65,16 @@ private: int init_operation_db (void); // initialize the operation database - int run_linear_test (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + int run_linear_test (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); // run linear strategy - int run_random_test (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + int run_random_test (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); // run random strategy - int run_best_test (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + int run_best_test (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); // run best strategy (w.r.t to linear) - int run_worst_test (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); + int run_worst_test (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS); // run worst strategy (w.r.t to linear) int print_results (void); diff --git a/TAO/performance-tests/POA/Demux/demux_test_client.i b/TAO/performance-tests/POA/Demux/demux_test_client.i index 9a113cb2f85..0d2081ee78c 100644 --- a/TAO/performance-tests/POA/Demux/demux_test_client.i +++ b/TAO/performance-tests/POA/Demux/demux_test_client.i @@ -1,14 +1,14 @@ //$Id$ static void M302 (Demux_Test_ptr objref - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { - objref->M302 (TAO_ENV_SINGLE_ARG_PARAMETER); + objref->M302 (ACE_ENV_SINGLE_ARG_PARAMETER); } static void shutdown (Demux_Test_ptr objref - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { - objref->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + objref->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); } int Demux_Test_Client::init_operation_db (void) diff --git a/TAO/performance-tests/POA/Demux/demux_test_i.cpp b/TAO/performance-tests/POA/Demux/demux_test_i.cpp index d20766f2711..c8810c36650 100644 --- a/TAO/performance-tests/POA/Demux/demux_test_i.cpp +++ b/TAO/performance-tests/POA/Demux/demux_test_i.cpp @@ -12,12 +12,12 @@ Demux_Test_i::Demux_Test_i (void) Demux_Test_i::~Demux_Test_i (void) {} -void Demux_Test_i::M302 (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +void Demux_Test_i::M302 (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } -void Demux_Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +void Demux_Test_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { TAO_ORB_Core_instance ()->orb ()->shutdown (); diff --git a/TAO/performance-tests/POA/Demux/demux_test_i.h b/TAO/performance-tests/POA/Demux/demux_test_i.h index ffa9d017ec2..6d302340364 100644 --- a/TAO/performance-tests/POA/Demux/demux_test_i.h +++ b/TAO/performance-tests/POA/Demux/demux_test_i.h @@ -24,15 +24,15 @@ public: // dtor // Return the Default POA of this Servant - PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED/*env*/) + PortableServer::POA_ptr _default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED/*env*/) { return PortableServer::POA::_duplicate (this->poa_.in ()); }; - virtual void M302 (TAO_ENV_SINGLE_ARG_DECL) + virtual void M302 (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/performance-tests/POA/Demux/demux_test_server.cpp b/TAO/performance-tests/POA/Demux/demux_test_server.cpp index ec61f957ee0..52c2607319b 100644 --- a/TAO/performance-tests/POA/Demux/demux_test_server.cpp +++ b/TAO/performance-tests/POA/Demux/demux_test_server.cpp @@ -46,7 +46,7 @@ Demux_Test_Server::~Demux_Test_Server (void) int Demux_Test_Server::init (int argc, char *argv [] - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { printf ("here\n"); @@ -58,7 +58,7 @@ Demux_Test_Server::init (int argc, char *argv [] { // get the underlying ORB this->orb_ = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX(GET_ORB); } ACE_CATCHANY @@ -78,7 +78,7 @@ Demux_Test_Server::init (int argc, char *argv [] temp = this->orb_->resolve_initial_references ("RootPOA" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX(GET_ROOT_POA); if (CORBA::is_nil (temp.in ())) ACE_ERROR_RETURN ((LM_ERROR, @@ -87,7 +87,7 @@ Demux_Test_Server::init (int argc, char *argv [] this->root_poa_ = PortableServer::POA::_narrow (temp.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (GET_ROOT_POA); } ACE_CATCHANY @@ -104,7 +104,7 @@ Demux_Test_Server::init (int argc, char *argv [] { this->poa_mgr_ = - this->root_poa_->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + this->root_poa_->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (GET_POA_MGR); } ACE_CATCHANY @@ -147,7 +147,7 @@ Demux_Test_Server::init (int argc, char *argv [] policies[0] = this->root_poa_->create_id_assignment_policy (PortableServer::USER_ID - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } else { @@ -156,7 +156,7 @@ Demux_Test_Server::init (int argc, char *argv [] policies[0] = this->root_poa_->create_id_assignment_policy (PortableServer::SYSTEM_ID - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK_EX (POLICY); @@ -169,7 +169,7 @@ Demux_Test_Server::init (int argc, char *argv [] policies[1] = this->root_poa_->create_lifespan_policy (PortableServer::TRANSIENT - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } else { @@ -178,7 +178,7 @@ Demux_Test_Server::init (int argc, char *argv [] policies[1] = this->root_poa_->create_lifespan_policy (PortableServer::PERSISTENT - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } ACE_TRY_CHECK_EX (POLICY); @@ -230,7 +230,7 @@ Demux_Test_Server::init (int argc, char *argv [] this->child_poa_[i] = prev_poa->create_POA (poa_name, this->poa_mgr_.in (), policies - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (CREATE_POA); } ACE_CATCHANY @@ -258,7 +258,7 @@ Demux_Test_Server::init (int argc, char *argv [] //id = this->child_poa_[i]->activate_object (&this->demux_test_[j], id = this->child_poa_[i]->activate_object (demux_test_i_ptr - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (ACTIVATE_OBJ); } ACE_CATCHANY @@ -274,11 +274,11 @@ Demux_Test_Server::init (int argc, char *argv [] ACE_TRY_EX (IOR) { CORBA::Object_var demux_var = this->child_poa_[i]->id_to_reference (id.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (IOR); CORBA::String_var ior = this->orb_->object_to_string - (demux_var.in () TAO_ENV_ARG_PARAMETER); + (demux_var.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK_EX (IOR); @@ -319,16 +319,16 @@ Demux_Test_Server::init (int argc, char *argv [] this->child_poa_[i]->activate_object_with_id (oid.in (), demux_test_i_ptr - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get Object reference for demux_test_i impl object. - CORBA::Object_var demux_var = demux_test_i_ptr->_this (TAO_ENV_SINGLE_ARG_PARAMETER); + CORBA::Object_var demux_var = demux_test_i_ptr->_this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = this->orb_->object_to_string - (demux_var.in () TAO_ENV_ARG_PARAMETER); + (demux_var.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; @@ -359,7 +359,7 @@ Demux_Test_Server::init (int argc, char *argv [] ACE_TRY_EX (ACTIVATE) { - this->poa_mgr_->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + this->poa_mgr_->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK_EX (ACTIVATE); } @@ -468,11 +468,11 @@ Demux_Test_Server::init_naming_service (void) // The main program for Demux_Test int -Demux_Test_Server::run (TAO_ENV_SINGLE_ARG_DECL) +Demux_Test_Server::run (ACE_ENV_SINGLE_ARG_DECL) { ACE_TRY { - this->orb_->run (TAO_ENV_SINGLE_ARG_PARAMETER); + this->orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/performance-tests/POA/Demux/demux_test_server.h b/TAO/performance-tests/POA/Demux/demux_test_server.h index b0cc927ed31..588119e4e98 100644 --- a/TAO/performance-tests/POA/Demux/demux_test_server.h +++ b/TAO/performance-tests/POA/Demux/demux_test_server.h @@ -39,10 +39,10 @@ public: ~Demux_Test_Server (void); // dtor - int run (TAO_ENV_SINGLE_ARG_DECL_NOT_USED); + int run (ACE_ENV_SINGLE_ARG_DECL_NOT_USED); // Execute client code. - int init (int argc, char **argv TAO_ENV_ARG_DECL_NOT_USED); + int init (int argc, char **argv ACE_ENV_ARG_DECL_NOT_USED); // Initialize the communication endpoint with server. int calculate_avg_latency (void); diff --git a/TAO/performance-tests/POA/Demux/server.cpp b/TAO/performance-tests/POA/Demux/server.cpp index 27014a37cff..629bb31cf5f 100644 --- a/TAO/performance-tests/POA/Demux/server.cpp +++ b/TAO/performance-tests/POA/Demux/server.cpp @@ -34,13 +34,13 @@ int main (int argc, char *argv []) ACE_TRY_NEW_ENV { int r = - demux_test_server.init (argc, argv TAO_ENV_ARG_PARAMETER); + demux_test_server.init (argc, argv ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (r == -1) return -1; - demux_test_server.run (TAO_ENV_SINGLE_ARG_PARAMETER); + demux_test_server.run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCH (CORBA::SystemException, sysex) diff --git a/TAO/performance-tests/POA/Implicit_Activation/Factory.cpp b/TAO/performance-tests/POA/Implicit_Activation/Factory.cpp index 88490f1c62e..048928657c2 100644 --- a/TAO/performance-tests/POA/Implicit_Activation/Factory.cpp +++ b/TAO/performance-tests/POA/Implicit_Activation/Factory.cpp @@ -12,7 +12,7 @@ Factory::Factory (CORBA::ORB_ptr orb) } Test::Simple_ptr -Factory::create_simple_object (TAO_ENV_SINGLE_ARG_DECL) +Factory::create_simple_object (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { Simple *simple_impl; @@ -23,12 +23,12 @@ Factory::create_simple_object (TAO_ENV_SINGLE_ARG_DECL) PortableServer::ServantBase_var owner_transfer(simple_impl); - return simple_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); + return simple_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); } void -Factory::shutdown (TAO_ENV_SINGLE_ARG_DECL) +Factory::shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); } diff --git a/TAO/performance-tests/POA/Implicit_Activation/Factory.h b/TAO/performance-tests/POA/Implicit_Activation/Factory.h index 69967f06580..52e9055f912 100644 --- a/TAO/performance-tests/POA/Implicit_Activation/Factory.h +++ b/TAO/performance-tests/POA/Implicit_Activation/Factory.h @@ -26,10 +26,10 @@ public: // = The skeleton methods - virtual Test::Simple_ptr create_simple_object (TAO_ENV_SINGLE_ARG_DECL) + virtual Test::Simple_ptr create_simple_object (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/performance-tests/POA/Implicit_Activation/Simple.cpp b/TAO/performance-tests/POA/Implicit_Activation/Simple.cpp index 6ff7ad5edb4..f15b8b826ff 100644 --- a/TAO/performance-tests/POA/Implicit_Activation/Simple.cpp +++ b/TAO/performance-tests/POA/Implicit_Activation/Simple.cpp @@ -10,16 +10,16 @@ Simple::Simple (void) } void -Simple::destroy (TAO_ENV_SINGLE_ARG_DECL) +Simple::destroy (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - PortableServer::POA_var poa = this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); + PortableServer::POA_var poa = this->_default_POA (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK; PortableServer::ObjectId_var oid = - poa->servant_to_id (this TAO_ENV_ARG_PARAMETER); + poa->servant_to_id (this ACE_ENV_ARG_PARAMETER); ACE_CHECK; - poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER); + poa->deactivate_object (oid.in () ACE_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/performance-tests/POA/Implicit_Activation/Simple.h b/TAO/performance-tests/POA/Implicit_Activation/Simple.h index a0a6059ef09..d3dffbde564 100644 --- a/TAO/performance-tests/POA/Implicit_Activation/Simple.h +++ b/TAO/performance-tests/POA/Implicit_Activation/Simple.h @@ -26,7 +26,7 @@ public: // = The skeleton methods - virtual void destroy (TAO_ENV_SINGLE_ARG_DECL) + virtual void destroy (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); }; diff --git a/TAO/performance-tests/POA/Implicit_Activation/client.cpp b/TAO/performance-tests/POA/Implicit_Activation/client.cpp index d01a1f9bc01..14da618907c 100644 --- a/TAO/performance-tests/POA/Implicit_Activation/client.cpp +++ b/TAO/performance-tests/POA/Implicit_Activation/client.cpp @@ -80,18 +80,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Factory_var factory = - Test::Factory::_narrow (object.in () TAO_ENV_ARG_PARAMETER); + Test::Factory::_narrow (object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (factory.in ())) @@ -117,7 +117,7 @@ main (int argc, char *argv[]) ACE_hrtime_t start = ACE_OS::gethrtime (); references[i] = - factory->create_simple_object (TAO_ENV_SINGLE_ARG_PARAMETER); + factory->create_simple_object (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_hrtime_t now = ACE_OS::gethrtime (); @@ -141,7 +141,7 @@ main (int argc, char *argv[]) { ACE_hrtime_t start = ACE_OS::gethrtime (); - references[j]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + references[j]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_hrtime_t now = ACE_OS::gethrtime (); @@ -160,7 +160,7 @@ main (int argc, char *argv[]) if (do_shutdown) { - factory->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + factory->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/performance-tests/POA/Implicit_Activation/collocated.cpp b/TAO/performance-tests/POA/Implicit_Activation/collocated.cpp index 45be6a48f92..2a79b9ce374 100644 --- a/TAO/performance-tests/POA/Implicit_Activation/collocated.cpp +++ b/TAO/performance-tests/POA/Implicit_Activation/collocated.cpp @@ -72,11 +72,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -85,14 +85,14 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -119,7 +119,7 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(simple_impl); references[i] = - simple_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); + simple_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_hrtime_t now = ACE_OS::gethrtime (); @@ -143,7 +143,7 @@ main (int argc, char *argv[]) { ACE_hrtime_t start = ACE_OS::gethrtime (); - references[j]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + references[j]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_hrtime_t now = ACE_OS::gethrtime (); @@ -160,10 +160,10 @@ main (int argc, char *argv[]) destruction.collect_basic_stats (destruction_stats); destruction_stats.dump_results ("Destruction", gsf); - root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/performance-tests/POA/Implicit_Activation/server.cpp b/TAO/performance-tests/POA/Implicit_Activation/server.cpp index 97ae513f2e5..89252e82dbd 100644 --- a/TAO/performance-tests/POA/Implicit_Activation/server.cpp +++ b/TAO/performance-tests/POA/Implicit_Activation/server.cpp @@ -62,11 +62,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -75,11 +75,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -92,11 +92,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var owner_transfer(factory_impl); Test::Factory_var factory = - factory_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); + factory_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (factory.in () TAO_ENV_ARG_PARAMETER); + orb->object_to_string (factory.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -109,18 +109,18 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); - root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/performance-tests/POA/Object_Creation_And_Registration/registration.cpp b/TAO/performance-tests/POA/Object_Creation_And_Registration/registration.cpp index ecb844d0187..a0c3544bc95 100644 --- a/TAO/performance-tests/POA/Object_Creation_And_Registration/registration.cpp +++ b/TAO/performance-tests/POA/Object_Creation_And_Registration/registration.cpp @@ -243,7 +243,7 @@ private: void child_poa_testing (PortableServer::POA_ptr root_poa - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { // Policies for the child POA. CORBA::PolicyList policies (1); @@ -252,7 +252,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa // Id Assignment Policy policies[0] = root_poa->create_id_assignment_policy (PortableServer::USER_ID - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Create the child POA under the RootPOA. @@ -260,7 +260,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa root_poa->create_POA ("child POA", PortableServer::POAManager::_nil (), policies - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; // Create an array of servants @@ -299,7 +299,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa objects[i] = child_poa->create_reference_with_id (object_ids[i].in (), "IDL:test:1.0" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -314,7 +314,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa { child_poa->activate_object_with_id (object_ids[i].in (), &servants[i] - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -328,7 +328,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa for (i = 0; i < iterations; i++) { child_poa->deactivate_object (object_ids[i].in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -342,7 +342,7 @@ child_poa_testing (PortableServer::POA_ptr root_poa int main (int argc, char **argv) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { @@ -350,7 +350,7 @@ main (int argc, char **argv) CORBA::ORB_var orb = CORBA::ORB_init (argc, argv, 0 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = parse_args (argc, argv); @@ -359,13 +359,13 @@ main (int argc, char **argv) // Obtain the RootPOA. CORBA::Object_var obj = orb->resolve_initial_references ("RootPOA" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the POA_var object from Object_var. PortableServer::POA_var root_poa = PortableServer::POA::_narrow (obj.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Create an array of servants @@ -395,7 +395,7 @@ main (int argc, char **argv) for (i = 0; i < iterations; i++) { - objects[i] = servants[i]._this (TAO_ENV_SINGLE_ARG_PARAMETER); + objects[i] = servants[i]._this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -408,20 +408,20 @@ main (int argc, char **argv) for (i = 0; i < iterations; i++) { object_ids[i] = root_poa->servant_to_id (&servants[i] - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } // Create the child POA. child_poa_testing (root_poa.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Destroy RootPOA. root_poa->destroy (1, 1 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Cleanup diff --git a/TAO/performance-tests/Pluggable/PP_Test_Client.cpp b/TAO/performance-tests/Pluggable/PP_Test_Client.cpp index 060dcfb62f8..3f5332de63a 100644 --- a/TAO/performance-tests/Pluggable/PP_Test_Client.cpp +++ b/TAO/performance-tests/Pluggable/PP_Test_Client.cpp @@ -165,12 +165,12 @@ PP_Test_Client::parse_args (void) void PP_Test_Client::send_oneway (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_SEND_ONEWAY_START); - this->objref_->send_oneway (TAO_ENV_SINGLE_ARG_PARAMETER); + this->objref_->send_oneway (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->call_count_++; } @@ -190,12 +190,12 @@ PP_Test_Client::send_oneway (void) void PP_Test_Client::send_void (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_SEND_VOID_START); - this->objref_->send_void (TAO_ENV_SINGLE_ARG_PARAMETER); + this->objref_->send_void (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; this->call_count_++; } @@ -259,7 +259,7 @@ PP_Test_Client::run () int PP_Test_Client::shutdown_server (int do_shutdown) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { @@ -268,7 +268,7 @@ PP_Test_Client::shutdown_server (int do_shutdown) ACE_DEBUG ((LM_DEBUG, "shutdown on Pluggable_Test object\n")); - this->objref_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + this->objref_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; @@ -290,7 +290,7 @@ PP_Test_Client::shutdown_server (int do_shutdown) int PP_Test_Client::run_oneway (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { @@ -312,7 +312,7 @@ PP_Test_Client::run_oneway (void) ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_SERVER_SHUTDOWN_START); - this->objref_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + this->objref_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -333,7 +333,7 @@ PP_Test_Client::run_oneway (void) int PP_Test_Client::run_void (void) { - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { @@ -355,7 +355,7 @@ PP_Test_Client::run_void (void) ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_SERVER_SHUTDOWN_START); - this->objref_->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + this->objref_->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -404,7 +404,7 @@ PP_Test_Client::init (int argc, char **argv) this->orb_ = CORBA::ORB_init (this->argc_, this->argv_, "internet" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse command line and verify parameters. if (this->parse_args () == -1) @@ -422,12 +422,12 @@ PP_Test_Client::init (int argc, char **argv) CORBA::Object_var factory_object = this->orb_->string_to_object (this->factory_key_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; this->factory_ = Pluggable_Test_Factory::_narrow (factory_object.in() - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->factory_.in ())) @@ -444,7 +444,7 @@ PP_Test_Client::init (int argc, char **argv) // Now retrieve the Pluggable_Test obj ref corresponding to the key. ACE_FUNCTION_TIMEPROBE (PP_TEST_CLIENT_MAKE_PLUGGABLE_START); - this->objref_ = this->factory_->make_pluggable_test (TAO_ENV_SINGLE_ARG_PARAMETER); + this->objref_ = this->factory_->make_pluggable_test (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (this->objref_.in ())) diff --git a/TAO/performance-tests/Pluggable/PP_Test_Server.cpp b/TAO/performance-tests/Pluggable/PP_Test_Server.cpp index c52492bca10..a9cb9133e53 100644 --- a/TAO/performance-tests/Pluggable/PP_Test_Server.cpp +++ b/TAO/performance-tests/Pluggable/PP_Test_Server.cpp @@ -49,14 +49,14 @@ PP_Test_Server::parse_args (void) int PP_Test_Server::init (int argc, char** argv - TAO_ENV_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER) + ACE_ENV_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER) { // Call the init of <TAO_ORB_Manager> to initialize the ORB and // create a child POA under the root POA. if (this->orb_manager_.init_child_poa (argc, argv, "child_poa" - TAO_ENV_ARG_PARAMETER) == -1) + ACE_ENV_ARG_PARAMETER) == -1) ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "init_child_poa"), @@ -79,7 +79,7 @@ PP_Test_Server::init (int argc, this->factory_id_ = this->orb_manager_.activate_under_child_poa ("factory", this->factory_impl_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); ACE_DEBUG ((LM_DEBUG, @@ -99,9 +99,9 @@ PP_Test_Server::init (int argc, } int -PP_Test_Server::run (TAO_ENV_SINGLE_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER) +PP_Test_Server::run (ACE_ENV_SINGLE_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER) { - int result = this->orb_manager_.run (TAO_ENV_SINGLE_ARG_PARAMETER); + int result = this->orb_manager_.run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); diff --git a/TAO/performance-tests/Pluggable/PP_Test_Server.h b/TAO/performance-tests/Pluggable/PP_Test_Server.h index 4be6dcaf311..f655b98caf0 100644 --- a/TAO/performance-tests/Pluggable/PP_Test_Server.h +++ b/TAO/performance-tests/Pluggable/PP_Test_Server.h @@ -50,10 +50,10 @@ public: int init (int argc, char **argv - TAO_ENV_ARG_DECL); + ACE_ENV_ARG_DECL); // Initialize the server state - parsing arguments, etc. - int run (TAO_ENV_SINGLE_ARG_DECL); + int run (ACE_ENV_SINGLE_ARG_DECL); // Run the orb private: diff --git a/TAO/performance-tests/Pluggable/PP_Test_i.cpp b/TAO/performance-tests/Pluggable/PP_Test_i.cpp index 25664e6986d..ac057c96481 100644 --- a/TAO/performance-tests/Pluggable/PP_Test_i.cpp +++ b/TAO/performance-tests/Pluggable/PP_Test_i.cpp @@ -38,7 +38,7 @@ static const char *PP_Test_i_Timeprobe_Description[] = enum { - // Timeprobe description table start key + // Timeprobe description table start key PP_TEST_I_SEND_ONEWAY_START = 10100, PP_TEST_I_SEND_ONEWAY_END, @@ -72,11 +72,11 @@ Pluggable_Test_Factory_i::~Pluggable_Test_Factory_i (void) } Pluggable_Test_ptr -Pluggable_Test_Factory_i::make_pluggable_test (TAO_ENV_SINGLE_ARG_DECL) +Pluggable_Test_Factory_i::make_pluggable_test (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (PP_TEST_I_MAKE_PLUGGABLE_START); - return my_pluggable_test_._this (TAO_ENV_SINGLE_ARG_PARAMETER); + return my_pluggable_test_._this (ACE_ENV_SINGLE_ARG_PARAMETER); } // Constructor @@ -95,7 +95,7 @@ PP_Test_i::~PP_Test_i (void) // Oneway send void -PP_Test_i::send_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +PP_Test_i::send_oneway (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (PP_TEST_I_SEND_ONEWAY_START); @@ -104,7 +104,7 @@ PP_Test_i::send_oneway (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) // Twoway send void -PP_Test_i::send_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +PP_Test_i::send_void (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (PP_TEST_I_SEND_VOID_START); @@ -112,7 +112,7 @@ PP_Test_i::send_void (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) // Shutdown. -void PP_Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +void PP_Test_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_DEBUG ((LM_DEBUG, diff --git a/TAO/performance-tests/Pluggable/PP_Test_i.h b/TAO/performance-tests/Pluggable/PP_Test_i.h index 2c439e97528..1e866bb103b 100644 --- a/TAO/performance-tests/Pluggable/PP_Test_i.h +++ b/TAO/performance-tests/Pluggable/PP_Test_i.h @@ -34,15 +34,15 @@ public: ~PP_Test_i (void); // Destructor - virtual void send_oneway (TAO_ENV_SINGLE_ARG_DECL) + virtual void send_oneway (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Test a oneway call. - virtual void send_void (TAO_ENV_SINGLE_ARG_DECL) + virtual void send_void (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Test a twoway call. - virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Shutdown routine. @@ -65,7 +65,7 @@ public: ~Pluggable_Test_Factory_i (void); // Destructor. - virtual Pluggable_Test_ptr make_pluggable_test (TAO_ENV_SINGLE_ARG_DECL) + virtual Pluggable_Test_ptr make_pluggable_test (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); // Make a Pluggable Test object. diff --git a/TAO/performance-tests/Pluggable/server.cpp b/TAO/performance-tests/Pluggable/server.cpp index 99b513899e8..6d781f12420 100644 --- a/TAO/performance-tests/Pluggable/server.cpp +++ b/TAO/performance-tests/Pluggable/server.cpp @@ -15,13 +15,13 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "\n\tPluggable_Test: server\n\n")); - TAO_ENV_DECLARE_NEW_ENV; + ACE_DECLARE_NEW_CORBA_ENV; ACE_TRY { int status = pp_test_server.init (argc, argv - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (status == -1) @@ -32,7 +32,7 @@ main (int argc, char *argv[]) } else { - pp_test_server.run (TAO_ENV_SINGLE_ARG_PARAMETER); + pp_test_server.run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.cpp index 3c40536d884..706289d63f9 100644 --- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.cpp +++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.cpp @@ -12,7 +12,7 @@ ACE_RCSID(Latency, test_i, "$Id$") void Test_i::test_method (CORBA::Long id - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (TAO_debug_level > 0) @@ -23,16 +23,16 @@ Test_i::test_method (CORBA::Long id void Test_i::shutdown (const char *orb_id - TAO_ENV_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER) + ACE_ENV_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER) ACE_THROW_SPEC ((CORBA::SystemException)) { int argc = 0; CORBA::ORB_var orb = CORBA::ORB_init (argc, 0, orb_id - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; - orb->shutdown (0 TAO_ENV_ARG_PARAMETER); + orb->shutdown (0 ACE_ENV_ARG_PARAMETER); ACE_CHECK; } diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.h b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.h index a3d93fa6f2d..2a3de616b96 100644 --- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.h +++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Common/test_i.h @@ -32,11 +32,11 @@ public: // = The Test methods. void test_method (CORBA::Long id - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); void shutdown (const char *orb_id - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); }; diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/client.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/client.cpp index ab4e491160b..971444dd810 100644 --- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/client.cpp +++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/client.cpp @@ -141,7 +141,7 @@ main (int argc, char *argv[]) ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -150,12 +150,12 @@ main (int argc, char *argv[]) // Obtain Priority Mapping used by the ORB. CORBA::Object_var object = orb->resolve_initial_references ("PriorityMappingManager" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityMappingManager_var mapping_manager = RTCORBA::PriorityMappingManager::_narrow (object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (mapping_manager.in ())) @@ -260,11 +260,11 @@ Client::svc (void) priorities[this->id_]); CORBA::Object_var object = - orb_->string_to_object (ior TAO_ENV_ARG_PARAMETER); + orb_->string_to_object (ior ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var server = - Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); + Test::_narrow (object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -282,11 +282,11 @@ Client::svc (void) { /* CORBA::PolicyList_var pols; server->_validate_connection (pols.out () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); */ server->test_method (this->id_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -301,7 +301,7 @@ Client::svc (void) // Invoke method. server->test_method (this->id_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Grab timestamp again. @@ -320,7 +320,7 @@ Client::svc (void) /* char orb_name[50]; ACE_OS::sprintf (orb_name, "%d", priorities[this->id_]); - server->shutdown (orb_name TAO_ENV_ARG_PARAMETER); + server->shutdown (orb_name ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK;*/ } ACE_CATCHANY diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/server.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/server.cpp index 3ed70825ae0..2b54912aca0 100644 --- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/server.cpp +++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Orb_Per_Priority/server.cpp @@ -120,7 +120,7 @@ main (int argc, char *argv[]) int argc_ = argc; for (int i = 0; i < argc; ++i) argv_[i] = argv[i]; - orb = CORBA::ORB_init (argc_, argv_, "" TAO_ENV_ARG_PARAMETER); + orb = CORBA::ORB_init (argc_, argv_, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Parse the arguments. @@ -130,12 +130,12 @@ main (int argc, char *argv[]) // Obtain Priority Mapping used by the ORB. CORBA::Object_var object = orb->resolve_initial_references ("PriorityMappingManager" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityMappingManager_var mapping_manager = RTCORBA::PriorityMappingManager::_narrow (object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (mapping_manager.in ())) @@ -214,11 +214,11 @@ Server::svc (void) char orb_name[64]; ACE_OS::sprintf (orb_name, "%d", this->priority_); CORBA::ORB_var orb = - CORBA::ORB_init (argc_, argv_, orb_name TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc_, argv_, orb_name ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -227,23 +227,23 @@ Server::svc (void) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::ObjectId_var oid = - root_poa->activate_object (this->server_ TAO_ENV_ARG_PARAMETER); + root_poa->activate_object (this->server_ ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var obj = - root_poa->id_to_reference (oid.in () TAO_ENV_ARG_PARAMETER); + root_poa->id_to_reference (oid.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (obj.in () TAO_ENV_ARG_PARAMETER); + orb->object_to_string (obj.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -266,10 +266,10 @@ Server::svc (void) ACE_OS::fclose (output_file); // Start orb event loop. - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/client.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/client.cpp index febe0cde286..d128bcd1ae9 100644 --- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/client.cpp +++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/client.cpp @@ -141,18 +141,18 @@ main (int argc, char *argv[]) ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var object = - orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var server = - Test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); + Test::_narrow (object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (server.in ())) @@ -165,12 +165,12 @@ main (int argc, char *argv[]) // Obtain Priority Mapping used by the ORB. object = orb->resolve_initial_references ("PriorityMappingManager" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityMappingManager_var mapping_manager = RTCORBA::PriorityMappingManager::_narrow (object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (mapping_manager.in ())) @@ -222,7 +222,7 @@ main (int argc, char *argv[]) } throughput.dump_results ("Aggregated", gsf); - server->shutdown ("" TAO_ENV_ARG_PARAMETER); + server->shutdown ("" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -286,11 +286,11 @@ Client::svc (void) { /* CORBA::PolicyList_var pols; server_->_validate_connection (pols.out () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); */ server_->test_method (this->id_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -305,7 +305,7 @@ Client::svc (void) // Invoke method. server_->test_method (this->id_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Grab timestamp again. diff --git a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/server.cpp b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/server.cpp index 5a7a5f2aea7..7b623eadc7e 100644 --- a/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/server.cpp +++ b/TAO/performance-tests/RTCorba/Multiple_Endpoints/Single_Endpoint/server.cpp @@ -59,11 +59,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -72,11 +72,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -85,11 +85,11 @@ main (int argc, char *argv[]) Test_i server_impl; Test_var server = - server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); + server_impl._this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (server.in () TAO_ENV_ARG_PARAMETER); + orb->object_to_string (server.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Activated as <%s>\n", ior.in ())); @@ -107,10 +107,10 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); } - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); diff --git a/TAO/performance-tests/RTCorba/Oneways/Reliable/client.cpp b/TAO/performance-tests/RTCorba/Oneways/Reliable/client.cpp index 58b3e73585e..1f7ef7a756a 100644 --- a/TAO/performance-tests/RTCorba/Oneways/Reliable/client.cpp +++ b/TAO/performance-tests/RTCorba/Oneways/Reliable/client.cpp @@ -135,7 +135,7 @@ print_params (void) static void twoway_work_test (Test_ptr server - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { #if defined (USING_TIMERS) ACE_Throughput_Stats latency; @@ -156,7 +156,7 @@ twoway_work_test (Test_ptr server #endif /* USING_TIMERS */ server->twoway_work_test (work - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; #if defined (USING_TIMERS) @@ -180,7 +180,7 @@ twoway_work_test (Test_ptr server static void oneway_work_test (Test_ptr server - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { #if defined (USING_TIMERS) ACE_Throughput_Stats latency; @@ -201,7 +201,7 @@ oneway_work_test (Test_ptr server #endif /* USING_TIMERS */ server->oneway_work_test (work - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; #if defined (USING_TIMERS) @@ -225,7 +225,7 @@ oneway_work_test (Test_ptr server static void oneway_payload_test (Test_ptr server - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { #if defined (USING_TIMERS) ACE_Throughput_Stats latency; @@ -249,7 +249,7 @@ oneway_payload_test (Test_ptr server #endif /* USING_TIMERS */ server->oneway_payload_test (the_data - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; #if defined (USING_TIMERS) @@ -432,7 +432,7 @@ main (int argc, char *argv[]) CORBA::ORB_init (argc, argv, "" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the command line options. @@ -445,30 +445,30 @@ main (int argc, char *argv[]) CORBA::Object_var obj = orb->resolve_initial_references ("ORBPolicyManager" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyManager_var policy_manager = CORBA::PolicyManager::_narrow (obj.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; obj = orb->resolve_initial_references ("PolicyCurrent" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::PolicyCurrent_var policy_current = CORBA::PolicyCurrent::_narrow (obj.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; obj = orb->string_to_object (ior - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test_var server = Test::_narrow (obj.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Print testing parameters. @@ -478,7 +478,7 @@ main (int argc, char *argv[]) if (test_twoway) { twoway_work_test (server.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else @@ -495,7 +495,7 @@ main (int argc, char *argv[]) sync_scope_policy_list[0] = orb->create_policy (Messaging::SYNC_SCOPE_POLICY_TYPE, sync_scope_any - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; switch (level) @@ -504,7 +504,7 @@ main (int argc, char *argv[]) // Set the sync scope policy at the ORB level. policy_manager->set_policy_overrides (sync_scope_policy_list, CORBA::ADD_OVERRIDE - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; break; @@ -512,7 +512,7 @@ main (int argc, char *argv[]) // Set the sync scope policy at the thread level. policy_current->set_policy_overrides (sync_scope_policy_list, CORBA::ADD_OVERRIDE - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; break; @@ -520,12 +520,12 @@ main (int argc, char *argv[]) // Set the sync scope policy at the object level. obj = server->_set_policy_overrides (sync_scope_policy_list, CORBA::ADD_OVERRIDE - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the new object reference with the updated policy. server = Test::_narrow (obj.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; break; @@ -534,7 +534,7 @@ main (int argc, char *argv[]) } // We are done with this policy. - sync_scope_policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + sync_scope_policy_list[0]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Are we buffering the oneway requests? @@ -558,32 +558,32 @@ main (int argc, char *argv[]) buffering_constraint_policy_list[0] = orb->create_policy (TAO::BUFFERING_CONSTRAINT_POLICY_TYPE, buffering_constraint_any - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Set up the constraints (at the object level). obj = server->_set_policy_overrides (buffering_constraint_policy_list, CORBA::ADD_OVERRIDE - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // We are done with this policy. - buffering_constraint_policy_list[0]->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + buffering_constraint_policy_list[0]->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; // Get the new object reference with the updated policy. server = Test::_narrow (obj.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } // Run the oneway test. if (payload_test) oneway_payload_test (server.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); else oneway_work_test (server.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -592,7 +592,7 @@ main (int argc, char *argv[]) ACE_DEBUG ((LM_DEBUG, "\nShutting down server\n")); - server->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + server->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } @@ -602,7 +602,7 @@ main (int argc, char *argv[]) // static destructors to flush the queues, it will be too late. // Therefore, we use explicit destruction here and flush the // queues before main() ends. - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/performance-tests/RTCorba/Oneways/Reliable/server.cpp b/TAO/performance-tests/RTCorba/Oneways/Reliable/server.cpp index 89bc9f56bd4..b23da7d1bb9 100644 --- a/TAO/performance-tests/RTCorba/Oneways/Reliable/server.cpp +++ b/TAO/performance-tests/RTCorba/Oneways/Reliable/server.cpp @@ -95,7 +95,7 @@ main (int argc, char *argv[]) CORBA::ORB_init (argc, argv, "" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // Get the command line options. @@ -108,27 +108,27 @@ main (int argc, char *argv[]) CORBA::Object_var poa_object = orb->resolve_initial_references ("RootPOA" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = PortableServer::POA::_narrow (poa_object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; Test_i server_impl (orb.in ()); Test_var server = - server_impl._this (TAO_ENV_SINGLE_ARG_PARAMETER); + server_impl._this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = orb->object_to_string (server.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, @@ -149,17 +149,17 @@ main (int argc, char *argv[]) ACE_OS::fclose (output_file); - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "event loop finished\n")); root_poa->destroy (1, 1 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.cpp b/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.cpp index 17c0cfa9726..3062b3b2402 100644 --- a/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.cpp +++ b/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.cpp @@ -11,7 +11,7 @@ ACE_RCSID(Reliable, test_i, "$Id$") void Test_i::oneway_work_test (CORBA::ULong work - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { for (CORBA::ULong i = 0; i < work; i++) @@ -25,14 +25,14 @@ Test_i::oneway_work_test (CORBA::ULong work void Test_i::oneway_payload_test (const Test::data & - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { } void Test_i::twoway_work_test (CORBA::ULong work - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { for (CORBA::ULong i = 0; i < work; i++) @@ -45,9 +45,9 @@ Test_i::twoway_work_test (CORBA::ULong work } void -Test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED TAO_ENV_SINGLE_ARG_PARAMETER) +Test_i::shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED ACE_ENV_SINGLE_ARG_PARAMETER) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (0 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); } diff --git a/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.h b/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.h index 2ef26b8c187..0359d3c1fa3 100644 --- a/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.h +++ b/TAO/performance-tests/RTCorba/Oneways/Reliable/test_i.h @@ -32,18 +32,18 @@ public: // = The Test methods. void oneway_payload_test (const Test::data &d - TAO_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); void oneway_work_test (CORBA::ULong work - TAO_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); void twoway_work_test (CORBA::ULong work - TAO_ENV_ARG_DECL_WITH_DEFAULTS) + ACE_ENV_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (TAO_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) + void shutdown (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/performance-tests/RTCorba/Thread_Pool/client.cpp b/TAO/performance-tests/RTCorba/Thread_Pool/client.cpp index a45471a31a4..1c565863857 100644 --- a/TAO/performance-tests/RTCorba/Thread_Pool/client.cpp +++ b/TAO/performance-tests/RTCorba/Thread_Pool/client.cpp @@ -249,7 +249,7 @@ start_synchronization (test_ptr test, { test->method (work, prime_number - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } } @@ -358,7 +358,7 @@ max_throughput (test_ptr test, ACE_TRY_NEW_ENV { CORBA_priority = - current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); + current->the_priority (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Boolean result = @@ -387,7 +387,7 @@ max_throughput (test_ptr test, test->method (work, prime_number - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ++calls_made; @@ -430,9 +430,9 @@ public: int svc (void); ACE_hrtime_t deadline_for_current_call (CORBA::ULong i); - void reset_priority (TAO_ENV_SINGLE_ARG_DECL); + void reset_priority (ACE_ENV_SINGLE_ARG_DECL); void print_stats (ACE_hrtime_t test_end); - int setup (TAO_ENV_SINGLE_ARG_DECL); + int setup (ACE_ENV_SINGLE_ARG_DECL); void missed_start_deadline (CORBA::ULong invocation); void missed_end_deadline (CORBA::ULong invocation); @@ -483,18 +483,18 @@ Paced_Worker::Paced_Worker (ACE_Thread_Manager &thread_manager, } void -Paced_Worker::reset_priority (TAO_ENV_SINGLE_ARG_DECL) +Paced_Worker::reset_priority (ACE_ENV_SINGLE_ARG_DECL) { if (set_priority) { this->current_->the_priority (this->priority_ - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; } else { this->current_->the_priority (continuous_worker_priority - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; } } @@ -600,16 +600,16 @@ Paced_Worker::print_stats (ACE_hrtime_t test_end) } int -Paced_Worker::setup (TAO_ENV_SINGLE_ARG_DECL) +Paced_Worker::setup (ACE_ENV_SINGLE_ARG_DECL) { if (priority_setting == AFTER_THREAD_CREATION) { - this->reset_priority (TAO_ENV_SINGLE_ARG_PARAMETER); + this->reset_priority (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); } this->CORBA_priority_ = - this->current_->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); + this->current_->the_priority (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::Boolean result = @@ -647,7 +647,7 @@ Paced_Worker::svc (void) ACE_TRY_NEW_ENV { int result = - this->setup (TAO_ENV_SINGLE_ARG_PARAMETER); + this->setup (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) @@ -671,7 +671,7 @@ Paced_Worker::svc (void) this->test_->method (work, prime_number - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_hrtime_t time_after_call = @@ -725,7 +725,7 @@ public: int svc (void); void print_stats (ACE_Sample_History &history, ACE_hrtime_t test_end); - int setup (TAO_ENV_SINGLE_ARG_DECL); + int setup (ACE_ENV_SINGLE_ARG_DECL); void print_collective_stats (void); test_var test_; @@ -827,17 +827,17 @@ Continuous_Worker::print_collective_stats (void) } int -Continuous_Worker::setup (TAO_ENV_SINGLE_ARG_DECL) +Continuous_Worker::setup (ACE_ENV_SINGLE_ARG_DECL) { if (priority_setting == AFTER_THREAD_CREATION) { this->current_->the_priority (continuous_worker_priority - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); } this->CORBA_priority_ = - this->current_->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); + this->current_->the_priority (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_CHECK_RETURN (-1); CORBA::Boolean result = @@ -862,7 +862,7 @@ Continuous_Worker::svc (void) ACE_Sample_History history (this->iterations_); int result = - this->setup (TAO_ENV_SINGLE_ARG_PARAMETER); + this->setup (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) @@ -876,7 +876,7 @@ Continuous_Worker::svc (void) this->test_->method (work, prime_number - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; ACE_hrtime_t end = ACE_OS::gethrtime (); @@ -911,7 +911,7 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -922,31 +922,31 @@ main (int argc, char *argv[]) fudge_priorities (orb.in ()); CORBA::Object_var object = - orb->string_to_object (ior TAO_ENV_ARG_PARAMETER); + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_var test = - test::_narrow (object.in () TAO_ENV_ARG_PARAMETER); + test::_narrow (object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = orb->resolve_initial_references ("RTCurrent" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = RTCORBA::Current::_narrow (object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = orb->resolve_initial_references ("PriorityMappingManager" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityMappingManager_var mapping_manager = RTCORBA::PriorityMappingManager::_narrow (object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::PriorityMapping &priority_mapping = @@ -1145,7 +1145,7 @@ main (int argc, char *argv[]) if (shutdown_server) { - test->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + test->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } } diff --git a/TAO/performance-tests/RTCorba/Thread_Pool/server.cpp b/TAO/performance-tests/RTCorba/Thread_Pool/server.cpp index ba0290feaa6..1521f88ee83 100644 --- a/TAO/performance-tests/RTCorba/Thread_Pool/server.cpp +++ b/TAO/performance-tests/RTCorba/Thread_Pool/server.cpp @@ -22,13 +22,13 @@ public: void method (CORBA::ULong work, CORBA::ULong prime_number - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - void shutdown (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) + void shutdown (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)); - PortableServer::POA_ptr _default_POA (TAO_ENV_SINGLE_ARG_DECL); + PortableServer::POA_ptr _default_POA (ACE_ENV_SINGLE_ARG_DECL); private: CORBA::ORB_var orb_; @@ -45,7 +45,7 @@ test_i::test_i (CORBA::ORB_ptr orb, void test_i::method (CORBA::ULong work, CORBA::ULong prime_number - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { if (TAO_debug_level > 0) @@ -60,17 +60,17 @@ test_i::method (CORBA::ULong work, } PortableServer::POA_ptr -test_i::_default_POA (TAO_ENV_SINGLE_ARG_DECL_NOT_USED) +test_i::_default_POA (ACE_ENV_SINGLE_ARG_DECL_NOT_USED) { return PortableServer::POA::_duplicate (this->poa_.in ()); } void -test_i::shutdown (TAO_ENV_SINGLE_ARG_DECL) +test_i::shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { this->orb_->shutdown (0 - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK; } @@ -170,11 +170,11 @@ int write_ior_to_file (const char *ior_file, CORBA::ORB_ptr orb, CORBA::Object_ptr object - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) { CORBA::String_var ior = orb->object_to_string (object - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_CHECK_RETURN (-1); FILE *output_file = @@ -205,47 +205,47 @@ main (int argc, char *argv[]) CORBA::ORB_init (argc, argv, "" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; fudge_priorities (orb.in ()); CORBA::Object_var object = orb->resolve_initial_references ("RootPOA" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var root_poa = PortableServer::POA::_narrow (object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; object = orb->resolve_initial_references ("RTORB" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::RTORB_var rt_orb = RTCORBA::RTORB::_narrow (object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; object = orb->resolve_initial_references ("RTCurrent" - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; RTCORBA::Current_var current = RTCORBA::Current::_narrow (object.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; default_thread_priority = - current->the_priority (TAO_ENV_SINGLE_ARG_PARAMETER); + current->the_priority (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; int result = @@ -273,7 +273,7 @@ main (int argc, char *argv[]) max_request_buffer_size, allow_borrowing, policies - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } else if (ACE_OS::strcmp (lanes_file, "empty-file") != 0) @@ -290,7 +290,7 @@ main (int argc, char *argv[]) max_request_buffer_size, allow_borrowing, policies - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) @@ -301,7 +301,7 @@ main (int argc, char *argv[]) bands_file, rt_orb.in (), policies - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) @@ -321,13 +321,13 @@ main (int argc, char *argv[]) allow_request_buffering, max_buffered_requests, max_request_buffer_size - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policies.length (policies.length () + 1); policies[policies.length () - 1] = rt_orb->create_threadpool_policy (threadpool_id - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (ACE_OS::strcmp (bands_file, "empty-file") != 0) @@ -337,7 +337,7 @@ main (int argc, char *argv[]) bands_file, rt_orb.in (), policies - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) @@ -349,21 +349,21 @@ main (int argc, char *argv[]) policies[policies.length () - 1] = root_poa->create_implicit_activation_policy (PortableServer::IMPLICIT_ACTIVATION - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; policies.length (policies.length () + 1); policies[policies.length () - 1] = rt_orb->create_priority_model_policy (RTCORBA::CLIENT_PROPAGATED, default_thread_priority - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POA_var poa = root_poa->create_POA ("RT POA", poa_manager.in (), policies - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; test_i *servant = @@ -374,26 +374,26 @@ main (int argc, char *argv[]) ACE_UNUSED_ARG (safe_servant); test_var test = - servant->_this (TAO_ENV_SINGLE_ARG_PARAMETER); + servant->_this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; result = write_ior_to_file (ior_output_file, orb.in (), test.in () - TAO_ENV_ARG_PARAMETER); + ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (result != 0) return result; - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.cpp b/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.cpp new file mode 100644 index 00000000000..72f83576b44 --- /dev/null +++ b/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.cpp @@ -0,0 +1,26 @@ +// +// $Id$ +// +#include "Roundtrip.h" + +ACE_RCSID(Single_Threaded_Latency, Roundtrip, "$Id$") + +Roundtrip::Roundtrip (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +Test::Timestamp +Roundtrip::test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return send_time; +} + +void +Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} diff --git a/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.h b/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.h new file mode 100644 index 00000000000..efef33dd7e6 --- /dev/null +++ b/TAO/performance-tests/Single_Threaded_Latency/Roundtrip.h @@ -0,0 +1,46 @@ +// +// $Id$ +// + +#ifndef ROUNDTRIP_H +#define ROUNDTRIP_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::Roundtrip interface +class Roundtrip + : public virtual POA_Test::Roundtrip + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Roundtrip (CORBA::ORB_ptr orb); + + // = The skeleton methods + virtual Test::Timestamp test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ROUNDTRIP_H */ diff --git a/TAO/performance-tests/Single_Threaded_Latency/client.cpp b/TAO/performance-tests/Single_Threaded_Latency/client.cpp new file mode 100644 index 00000000000..2d841b9909d --- /dev/null +++ b/TAO/performance-tests/Single_Threaded_Latency/client.cpp @@ -0,0 +1,164 @@ +// $Id$ + +#include "TestC.h" +#include "ace/Get_Opt.h" +#include "ace/High_Res_Timer.h" +#include "ace/Sched_Params.h" +#include "ace/Stats.h" +#include "ace/Sample_History.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(Single_Threaded_Latency, client, "$Id$") + +const char *ior = "file://test.ior"; +int niterations = 100; +int do_dump_history = 0; +int do_shutdown = 1; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "hxk:i:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'h': + do_dump_history = 1; + break; + + case 'x': + do_shutdown = 0; + break; + + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "-i <niterations> " + "-x (disable shutdown) " + "-h (dump history) " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "client (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "client (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Test::Roundtrip_var roundtrip = + Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (roundtrip.in ())) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Nil Test::Roundtrip reference <%s>\n", + ior), + 1); + } + + for (int j = 0; j < 100; ++j) + { + ACE_hrtime_t start = 0; + (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + + ACE_Sample_History history (niterations); + + ACE_hrtime_t test_start = ACE_OS::gethrtime (); + for (int i = 0; i < niterations; ++i) + { + ACE_hrtime_t start = ACE_OS::gethrtime (); + + (void) roundtrip->test_method (start ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_hrtime_t now = ACE_OS::gethrtime (); + history.sample (now - start); + } + + ACE_hrtime_t test_end = ACE_OS::gethrtime (); + + ACE_DEBUG ((LM_DEBUG, "test finished\n")); + + ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration....")); + ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); + ACE_DEBUG ((LM_DEBUG, "done\n")); + + if (do_dump_history) + { + history.dump_samples ("HISTORY", gsf); + } + + ACE_Basic_Stats stats; + history.collect_basic_stats (stats); + stats.dump_results ("Total", gsf); + + ACE_Throughput_Stats::dump_throughput ("Total", gsf, + test_end - test_start, + stats.samples_count ()); + + if (do_shutdown) + { + roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Single_Threaded_Latency/server.cpp b/TAO/performance-tests/Single_Threaded_Latency/server.cpp new file mode 100644 index 00000000000..e96f0ff595a --- /dev/null +++ b/TAO/performance-tests/Single_Threaded_Latency/server.cpp @@ -0,0 +1,136 @@ +// $Id$ + +#include "Roundtrip.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(Single_Threaded_Latency, 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.opt_arg (); + 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[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority); + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "server (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "server (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + 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_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Roundtrip *roundtrip_impl; + ACE_NEW_RETURN (roundtrip_impl, + Roundtrip (orb.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(roundtrip_impl); + + Test::Roundtrip_var roundtrip = + roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER); + 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_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.cpp b/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.cpp new file mode 100644 index 00000000000..09d15331436 --- /dev/null +++ b/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.cpp @@ -0,0 +1,65 @@ +// +// $Id$ +// +#include "Client_Task.h" + +ACE_RCSID(Thread_Per_Connection_Latency, Client_Task, "$Id$") + +Client_Task::Client_Task (Test::Roundtrip_ptr roundtrip, + int niterations) + : roundtrip_ (Test::Roundtrip::_duplicate (roundtrip)) + , niterations_ (niterations) +{ +} + +int +Client_Task::svc (void) +{ + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + this->validate_connection (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + for (int i = 0; i != this->niterations_; ++i) + { + CORBA::ULongLong start = ACE_OS::gethrtime (); + + (void) this->roundtrip_->test_method (start ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_hrtime_t now = ACE_OS::gethrtime (); + this->latency_.sample (now - start); + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +void +Client_Task::accumulate_and_dump (ACE_Basic_Stats &totals, + const char *msg, + ACE_UINT32 gsf) +{ + totals.accumulate (this->latency_); + this->latency_.dump_results (msg, gsf); +} + +void +Client_Task::validate_connection (ACE_ENV_SINGLE_ARG_DECL) +{ + CORBA::ULongLong dummy = 0; + for (int i = 0; i != 100; ++i) + { + ACE_TRY + { + (void) this->roundtrip_->test_method (dummy ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY {} ACE_ENDTRY; + } +} diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.h b/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.h new file mode 100644 index 00000000000..ffc4e9d6b6a --- /dev/null +++ b/TAO/performance-tests/Thread_Per_Connection_Latency/Client_Task.h @@ -0,0 +1,46 @@ +// +// $Id$ +// + +#ifndef CLIENT_TASK_H +#define CLIENT_TASK_H +#include "ace/pre.h" + +#include "TestC.h" +#include "ace/Task.h" +#include "ace/Basic_Stats.h" + +/// Implement the Test::Client_Task interface +class Client_Task : public ACE_Task_Base +{ +public: + /// Constructor + Client_Task (Test::Roundtrip_ptr roundtrip, + int niterations); + + /// Add this thread results to the global numbers and print the + /// per-thread results. + void accumulate_and_dump (ACE_Basic_Stats &totals, + const char *msg, + ACE_UINT32 gsf); + + /// The service method + virtual int svc (void); + +private: + /// Make sure that the current thread has a connection available. + void validate_connection (ACE_ENV_SINGLE_ARG_DECL); + +private: + /// The object reference used for this test + Test::Roundtrip_var roundtrip_; + + /// The number of iterations + int niterations_; + + /// Keep track of the latency (minimum, average, maximum and jitter) + ACE_Basic_Stats latency_; +}; + +#include "ace/post.h" +#endif /* CLIENT_TASK_H */ diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.cpp b/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.cpp new file mode 100644 index 00000000000..2bc67948fd0 --- /dev/null +++ b/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.cpp @@ -0,0 +1,26 @@ +// +// $Id$ +// +#include "Roundtrip.h" + +ACE_RCSID(Single_Per_Connection_Latency, Roundtrip, "$Id$") + +Roundtrip::Roundtrip (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +Test::Timestamp +Roundtrip::test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return send_time; +} + +void +Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.h b/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.h new file mode 100644 index 00000000000..efef33dd7e6 --- /dev/null +++ b/TAO/performance-tests/Thread_Per_Connection_Latency/Roundtrip.h @@ -0,0 +1,46 @@ +// +// $Id$ +// + +#ifndef ROUNDTRIP_H +#define ROUNDTRIP_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::Roundtrip interface +class Roundtrip + : public virtual POA_Test::Roundtrip + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Roundtrip (CORBA::ORB_ptr orb); + + // = The skeleton methods + virtual Test::Timestamp test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ROUNDTRIP_H */ diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/client.cpp b/TAO/performance-tests/Thread_Per_Connection_Latency/client.cpp new file mode 100644 index 00000000000..69aac2b4ca5 --- /dev/null +++ b/TAO/performance-tests/Thread_Per_Connection_Latency/client.cpp @@ -0,0 +1,149 @@ +// $Id$ + +#include "Client_Task.h" +#include "ace/Get_Opt.h" +#include "ace/High_Res_Timer.h" +#include "ace/Sched_Params.h" +#include "ace/Stats.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(Thread_Per_Connection_Latency, client, "$Id$") + +const char *ior = "file://test.ior"; +int niterations = 1000; +int do_shutdown = 1; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "xk:i:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'x': + do_shutdown = 0; + break; + + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "-i <niterations> " + "-x (disable shutdown) " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "client (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "client (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Test::Roundtrip_var roundtrip = + Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (roundtrip.in ())) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Nil Test::Roundtrip reference <%s>\n", + ior), + 1); + } + + ACE_DEBUG ((LM_DEBUG, "Starting threads\n")); + + Client_Task task0(roundtrip.in (), niterations); + Client_Task task1(roundtrip.in (), niterations); + Client_Task task2(roundtrip.in (), niterations); + Client_Task task3(roundtrip.in (), niterations); + + ACE_hrtime_t test_start = ACE_OS::gethrtime (); + task0.activate(THR_NEW_LWP | THR_JOINABLE); + task1.activate(THR_NEW_LWP | THR_JOINABLE); + task2.activate(THR_NEW_LWP | THR_JOINABLE); + task3.activate(THR_NEW_LWP | THR_JOINABLE); + + task0.thr_mgr()->wait (); + ACE_hrtime_t test_end = ACE_OS::gethrtime (); + + ACE_DEBUG ((LM_DEBUG, "Threads finished\n")); + + ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration....")); + ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); + ACE_DEBUG ((LM_DEBUG, "done\n")); + + ACE_Basic_Stats totals; + task0.accumulate_and_dump (totals, "Task[0]", gsf); + task1.accumulate_and_dump (totals, "Task[1]", gsf); + task2.accumulate_and_dump (totals, "Task[2]", gsf); + task3.accumulate_and_dump (totals, "Task[3]", gsf); + + totals.dump_results ("Total", gsf); + + ACE_Throughput_Stats::dump_throughput ("Total", gsf, + test_end - test_start, + totals.samples_count ()); + + if (do_shutdown) + { + roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Thread_Per_Connection_Latency/server.cpp b/TAO/performance-tests/Thread_Per_Connection_Latency/server.cpp new file mode 100644 index 00000000000..004ce70cebf --- /dev/null +++ b/TAO/performance-tests/Thread_Per_Connection_Latency/server.cpp @@ -0,0 +1,136 @@ +// $Id$ + +#include "Roundtrip.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(Thread_Per_Connection_Latency, 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.opt_arg (); + 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[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority); + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "server (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "server (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + 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_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Roundtrip *roundtrip_impl; + ACE_NEW_RETURN (roundtrip_impl, + Roundtrip (orb.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(roundtrip_impl); + + Test::Roundtrip_var roundtrip = + roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER); + 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_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Thread_Pool_Latency/Client_Task.cpp b/TAO/performance-tests/Thread_Pool_Latency/Client_Task.cpp new file mode 100644 index 00000000000..efb544633b2 --- /dev/null +++ b/TAO/performance-tests/Thread_Pool_Latency/Client_Task.cpp @@ -0,0 +1,65 @@ +// +// $Id$ +// +#include "Client_Task.h" + +ACE_RCSID(Thread_Pool_Latency, Client_Task, "$Id$") + +Client_Task::Client_Task (Test::Roundtrip_ptr roundtrip, + int niterations) + : roundtrip_ (Test::Roundtrip::_duplicate (roundtrip)) + , niterations_ (niterations) +{ +} + +int +Client_Task::svc (void) +{ + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + this->validate_connection (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + for (int i = 0; i != this->niterations_; ++i) + { + CORBA::ULongLong start = ACE_OS::gethrtime (); + + (void) this->roundtrip_->test_method (start ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + ACE_hrtime_t now = ACE_OS::gethrtime (); + this->latency_.sample (now - start); + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +void +Client_Task::accumulate_and_dump (ACE_Basic_Stats &totals, + const char *msg, + ACE_UINT32 gsf) +{ + totals.accumulate (this->latency_); + this->latency_.dump_results (msg, gsf); +} + +void +Client_Task::validate_connection (ACE_ENV_SINGLE_ARG_DECL) +{ + CORBA::ULongLong dummy = 0; + for (int i = 0; i != 100; ++i) + { + ACE_TRY + { + (void) this->roundtrip_->test_method (dummy ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY {} ACE_ENDTRY; + } +} diff --git a/TAO/performance-tests/Thread_Pool_Latency/Client_Task.h b/TAO/performance-tests/Thread_Pool_Latency/Client_Task.h new file mode 100644 index 00000000000..ffc4e9d6b6a --- /dev/null +++ b/TAO/performance-tests/Thread_Pool_Latency/Client_Task.h @@ -0,0 +1,46 @@ +// +// $Id$ +// + +#ifndef CLIENT_TASK_H +#define CLIENT_TASK_H +#include "ace/pre.h" + +#include "TestC.h" +#include "ace/Task.h" +#include "ace/Basic_Stats.h" + +/// Implement the Test::Client_Task interface +class Client_Task : public ACE_Task_Base +{ +public: + /// Constructor + Client_Task (Test::Roundtrip_ptr roundtrip, + int niterations); + + /// Add this thread results to the global numbers and print the + /// per-thread results. + void accumulate_and_dump (ACE_Basic_Stats &totals, + const char *msg, + ACE_UINT32 gsf); + + /// The service method + virtual int svc (void); + +private: + /// Make sure that the current thread has a connection available. + void validate_connection (ACE_ENV_SINGLE_ARG_DECL); + +private: + /// The object reference used for this test + Test::Roundtrip_var roundtrip_; + + /// The number of iterations + int niterations_; + + /// Keep track of the latency (minimum, average, maximum and jitter) + ACE_Basic_Stats latency_; +}; + +#include "ace/post.h" +#endif /* CLIENT_TASK_H */ diff --git a/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.cpp b/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.cpp new file mode 100644 index 00000000000..6028512202c --- /dev/null +++ b/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.cpp @@ -0,0 +1,26 @@ +// +// $Id$ +// +#include "Roundtrip.h" + +ACE_RCSID(Thread_Pool_Latency, Roundtrip, "$Id$") + +Roundtrip::Roundtrip (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +Test::Timestamp +Roundtrip::test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + return send_time; +} + +void +Roundtrip::shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); +} diff --git a/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.h b/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.h new file mode 100644 index 00000000000..efef33dd7e6 --- /dev/null +++ b/TAO/performance-tests/Thread_Pool_Latency/Roundtrip.h @@ -0,0 +1,46 @@ +// +// $Id$ +// + +#ifndef ROUNDTRIP_H +#define ROUNDTRIP_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::Roundtrip interface +class Roundtrip + : public virtual POA_Test::Roundtrip + , public virtual PortableServer::RefCountServantBase +{ +public: + /// Constructor + Roundtrip (CORBA::ORB_ptr orb); + + // = The skeleton methods + virtual Test::Timestamp test_method (Test::Timestamp send_time + ACE_ENV_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + /// Use an ORB reference to conver strings to objects and shutdown + /// the application. + CORBA::ORB_var orb_; +}; + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +# pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ROUNDTRIP_H */ diff --git a/TAO/performance-tests/Thread_Pool_Latency/Worker_Thread.cpp b/TAO/performance-tests/Thread_Pool_Latency/Worker_Thread.cpp new file mode 100644 index 00000000000..e485bb2b843 --- /dev/null +++ b/TAO/performance-tests/Thread_Pool_Latency/Worker_Thread.cpp @@ -0,0 +1,24 @@ +// +// $Id$ +// +#include "Worker_Thread.h" + +ACE_RCSID(Thread_Pool_Latency, Worker_Thread, "$Id$") + +Worker_Thread::Worker_Thread (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +int +Worker_Thread::svc (void) +{ + ACE_DECLARE_NEW_CORBA_ENV; + ACE_TRY + { + this->orb_->run (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY {} ACE_ENDTRY; + return 0; +} diff --git a/TAO/performance-tests/Thread_Pool_Latency/client.cpp b/TAO/performance-tests/Thread_Pool_Latency/client.cpp new file mode 100644 index 00000000000..643f541a53f --- /dev/null +++ b/TAO/performance-tests/Thread_Pool_Latency/client.cpp @@ -0,0 +1,149 @@ +// $Id$ + +#include "Client_Task.h" +#include "ace/Get_Opt.h" +#include "ace/High_Res_Timer.h" +#include "ace/Sched_Params.h" +#include "ace/Stats.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(Thread_Pool_Latency, client, "$Id$") + +const char *ior = "file://test.ior"; +int niterations = 1000; +int do_shutdown = 1; + +int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "xk:i:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'x': + do_shutdown = 0; + break; + + case 'k': + ior = get_opts.opt_arg (); + break; + + case 'i': + niterations = ACE_OS::atoi (get_opts.opt_arg ()); + break; + + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + "-k <ior> " + "-i <niterations> " + "-x (disable shutdown) " + "\n", + argv [0]), + -1); + } + // Indicates sucessful parsing of the command line + return 0; +} + +int +main (int argc, char *argv[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "client (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "client (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + CORBA::Object_var object = + orb->string_to_object (ior ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + Test::Roundtrip_var roundtrip = + Test::Roundtrip::_narrow (object.in () ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (CORBA::is_nil (roundtrip.in ())) + { + ACE_ERROR_RETURN ((LM_ERROR, + "Nil Test::Roundtrip reference <%s>\n", + ior), + 1); + } + + ACE_DEBUG ((LM_DEBUG, "Starting threads\n")); + + Client_Task task0(roundtrip.in (), niterations); + Client_Task task1(roundtrip.in (), niterations); + Client_Task task2(roundtrip.in (), niterations); + Client_Task task3(roundtrip.in (), niterations); + + ACE_hrtime_t test_start = ACE_OS::gethrtime (); + task0.activate(THR_NEW_LWP | THR_JOINABLE); + task1.activate(THR_NEW_LWP | THR_JOINABLE); + task2.activate(THR_NEW_LWP | THR_JOINABLE); + task3.activate(THR_NEW_LWP | THR_JOINABLE); + + task0.thr_mgr()->wait (); + ACE_hrtime_t test_end = ACE_OS::gethrtime (); + + ACE_DEBUG ((LM_DEBUG, "Threads finished\n")); + + ACE_DEBUG ((LM_DEBUG, "High resolution timer calibration....")); + ACE_UINT32 gsf = ACE_High_Res_Timer::global_scale_factor (); + ACE_DEBUG ((LM_DEBUG, "done\n")); + + ACE_Basic_Stats totals; + task0.accumulate_and_dump (totals, "Task[0]", gsf); + task1.accumulate_and_dump (totals, "Task[1]", gsf); + task2.accumulate_and_dump (totals, "Task[2]", gsf); + task3.accumulate_and_dump (totals, "Task[3]", gsf); + + totals.dump_results ("Total", gsf); + + ACE_Throughput_Stats::dump_throughput ("Total", gsf, + test_end - test_start, + totals.samples_count ()); + + if (do_shutdown) + { + roundtrip->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Thread_Pool_Latency/server.cpp b/TAO/performance-tests/Thread_Pool_Latency/server.cpp new file mode 100644 index 00000000000..bcacaf713c2 --- /dev/null +++ b/TAO/performance-tests/Thread_Pool_Latency/server.cpp @@ -0,0 +1,139 @@ +// $Id$ + +#include "Roundtrip.h" +#include "Worker_Thread.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" + +#include "tao/Strategies/advanced_resource.h" + +ACE_RCSID(Thread_Pool_Latency, 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.opt_arg (); + 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[]) +{ + int priority = + (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO) + + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2; + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority); + // Enable FIFO scheduling, e.g., RT scheduling class on Solaris. + + if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_PROCESS)) != 0) + { + if (ACE_OS::last_error () == EPERM) + { + ACE_DEBUG ((LM_DEBUG, + "server (%P|%t): user is not superuser, " + "test runs in time-shared class\n")); + } + else + ACE_ERROR ((LM_ERROR, + "server (%P|%t): sched_params failed\n")); + } + + ACE_TRY_NEW_ENV + { + CORBA::ORB_var orb = + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::Object_var poa_object = + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); + 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_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + PortableServer::POAManager_var poa_manager = + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (parse_args (argc, argv) != 0) + return 1; + + Roundtrip *roundtrip_impl; + ACE_NEW_RETURN (roundtrip_impl, + Roundtrip (orb.in ()), + 1); + PortableServer::ServantBase_var owner_transfer(roundtrip_impl); + + Test::Roundtrip_var roundtrip = + roundtrip_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + CORBA::String_var ior = + orb->object_to_string (roundtrip.in () ACE_ENV_ARG_PARAMETER); + 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_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + + Worker_Thread worker (orb.in ()); + + worker.activate (THR_NEW_LWP | THR_JOINABLE, 4, 1); + worker.thr_mgr ()->wait (); + + ACE_DEBUG ((LM_DEBUG, "(%P|%t) server - event loop finished\n")); + + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); + ACE_TRY_CHECK; + } + ACE_CATCHANY + { + ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "Exception caught:"); + return 1; + } + ACE_ENDTRY; + + return 0; +} diff --git a/TAO/performance-tests/Throughput/Receiver.cpp b/TAO/performance-tests/Throughput/Receiver.cpp index 05b0fe9a001..79ac824f5d4 100644 --- a/TAO/performance-tests/Throughput/Receiver.cpp +++ b/TAO/performance-tests/Throughput/Receiver.cpp @@ -18,7 +18,7 @@ Receiver::Receiver (void) void Receiver::receive_data (const Test::Message &the_message - TAO_ENV_ARG_DECL_NOT_USED) + ACE_ENV_ARG_DECL_NOT_USED) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_hrtime_t now = ACE_OS::gethrtime (); @@ -45,7 +45,7 @@ Receiver::receive_data (const Test::Message &the_message } void -Receiver::done (TAO_ENV_SINGLE_ARG_DECL) +Receiver::done (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { if (this->message_count_ == 0) @@ -87,12 +87,12 @@ Receiver::done (TAO_ENV_SINGLE_ARG_DECL) ACE_TRY { - PortableServer::POA_var poa = this->_default_POA (TAO_ENV_SINGLE_ARG_PARAMETER); + PortableServer::POA_var poa = this->_default_POA (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::ObjectId_var oid = - poa->servant_to_id (this TAO_ENV_ARG_PARAMETER); + poa->servant_to_id (this ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - poa->deactivate_object (oid.in () TAO_ENV_ARG_PARAMETER); + poa->deactivate_object (oid.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY {} ACE_ENDTRY; diff --git a/TAO/performance-tests/Throughput/Receiver.h b/TAO/performance-tests/Throughput/Receiver.h index ab15144cacb..8217c7d6505 100644 --- a/TAO/performance-tests/Throughput/Receiver.h +++ b/TAO/performance-tests/Throughput/Receiver.h @@ -26,10 +26,10 @@ public: // = The skeleton methods virtual void receive_data (const Test::Message &message - TAO_ENV_ARG_DECL) + ACE_ENV_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void done (TAO_ENV_SINGLE_ARG_DECL) + virtual void done (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/performance-tests/Throughput/Receiver_Factory.cpp b/TAO/performance-tests/Throughput/Receiver_Factory.cpp index 059a7d3bd6b..c804588b9b6 100644 --- a/TAO/performance-tests/Throughput/Receiver_Factory.cpp +++ b/TAO/performance-tests/Throughput/Receiver_Factory.cpp @@ -12,7 +12,7 @@ Receiver_Factory::Receiver_Factory (CORBA::ORB_ptr orb) } Test::Receiver_ptr -Receiver_Factory::create_receiver (TAO_ENV_SINGLE_ARG_DECL) +Receiver_Factory::create_receiver (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { Receiver *receiver_impl; @@ -22,12 +22,12 @@ Receiver_Factory::create_receiver (TAO_ENV_SINGLE_ARG_DECL) ACE_CHECK_RETURN (Test::Receiver::_nil ()); PortableServer::ServantBase_var transfer_ownership(receiver_impl); - return receiver_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); + return receiver_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); } void -Receiver_Factory::shutdown (TAO_ENV_SINGLE_ARG_DECL) +Receiver_Factory::shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)) { - this->orb_->shutdown (0 TAO_ENV_ARG_PARAMETER); + this->orb_->shutdown (0 ACE_ENV_ARG_PARAMETER); } diff --git a/TAO/performance-tests/Throughput/Receiver_Factory.h b/TAO/performance-tests/Throughput/Receiver_Factory.h index 0b557ad4f09..05ef98836cb 100644 --- a/TAO/performance-tests/Throughput/Receiver_Factory.h +++ b/TAO/performance-tests/Throughput/Receiver_Factory.h @@ -25,10 +25,10 @@ public: Receiver_Factory (CORBA::ORB_ptr orb); // = The skeleton methods - virtual Test::Receiver_ptr create_receiver (TAO_ENV_SINGLE_ARG_DECL) + virtual Test::Receiver_ptr create_receiver (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); - virtual void shutdown (TAO_ENV_SINGLE_ARG_DECL) + virtual void shutdown (ACE_ENV_SINGLE_ARG_DECL) ACE_THROW_SPEC ((CORBA::SystemException)); private: diff --git a/TAO/performance-tests/Throughput/client.cpp b/TAO/performance-tests/Throughput/client.cpp index e5ffb8b70fa..9d879e772d0 100644 --- a/TAO/performance-tests/Throughput/client.cpp +++ b/TAO/performance-tests/Throughput/client.cpp @@ -64,18 +64,18 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) return 1; CORBA::Object_var tmp = - orb->string_to_object(ior TAO_ENV_ARG_PARAMETER); + orb->string_to_object(ior ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; Test::Receiver_Factory_var receiver_factory = - Test::Receiver_Factory::_narrow(tmp.in () TAO_ENV_ARG_PARAMETER); + Test::Receiver_Factory::_narrow(tmp.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (receiver_factory.in ())) @@ -100,18 +100,18 @@ main (int argc, char *argv[]) message.the_payload.length (message_size); Test::Receiver_var receiver = - receiver_factory->create_receiver (TAO_ENV_SINGLE_ARG_PARAMETER); + receiver_factory->create_receiver (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_hrtime_t start = ACE_OS::gethrtime (); for (int i = 0; i != message_count; ++i) { message.message_id = i; - receiver->receive_data (message TAO_ENV_ARG_PARAMETER); + receiver->receive_data (message ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; } - receiver->done (TAO_ENV_SINGLE_ARG_PARAMETER); + receiver->done (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_hrtime_t elapsed_time = ACE_OS::gethrtime () - start; @@ -140,11 +140,11 @@ main (int argc, char *argv[]) if (do_shutdown) { - receiver_factory->shutdown (TAO_ENV_SINGLE_ARG_PARAMETER); + receiver_factory->shutdown (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY diff --git a/TAO/performance-tests/Throughput/server.cpp b/TAO/performance-tests/Throughput/server.cpp index 467c3cbe003..68afc375a0d 100644 --- a/TAO/performance-tests/Throughput/server.cpp +++ b/TAO/performance-tests/Throughput/server.cpp @@ -39,11 +39,11 @@ main (int argc, char *argv[]) ACE_TRY_NEW_ENV { CORBA::ORB_var orb = - CORBA::ORB_init (argc, argv, "" TAO_ENV_ARG_PARAMETER); + CORBA::ORB_init (argc, argv, "" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::Object_var poa_object = - orb->resolve_initial_references("RootPOA" TAO_ENV_ARG_PARAMETER); + orb->resolve_initial_references("RootPOA" ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; if (CORBA::is_nil (poa_object.in ())) @@ -52,11 +52,11 @@ main (int argc, char *argv[]) 1); PortableServer::POA_var root_poa = - PortableServer::POA::_narrow (poa_object.in () TAO_ENV_ARG_PARAMETER); + PortableServer::POA::_narrow (poa_object.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; PortableServer::POAManager_var poa_manager = - root_poa->the_POAManager (TAO_ENV_SINGLE_ARG_PARAMETER); + root_poa->the_POAManager (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; if (parse_args (argc, argv) != 0) @@ -69,11 +69,11 @@ main (int argc, char *argv[]) PortableServer::ServantBase_var receiver_factory_owner_transfer(receiver_factory_impl); Test::Receiver_Factory_var receiver_factory = - receiver_factory_impl->_this (TAO_ENV_SINGLE_ARG_PARAMETER); + receiver_factory_impl->_this (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; CORBA::String_var ior = - orb->object_to_string (receiver_factory.in () TAO_ENV_ARG_PARAMETER); + orb->object_to_string (receiver_factory.in () ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; // If the ior_output_file exists, output the ior to it @@ -86,18 +86,18 @@ main (int argc, char *argv[]) ACE_OS::fprintf (output_file, "%s", ior.in ()); ACE_OS::fclose (output_file); - poa_manager->activate (TAO_ENV_SINGLE_ARG_PARAMETER); + poa_manager->activate (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; - orb->run (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->run (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; ACE_DEBUG ((LM_DEBUG, "Server event loop finished\n")); - root_poa->destroy (1, 1 TAO_ENV_ARG_PARAMETER); + root_poa->destroy (1, 1 ACE_ENV_ARG_PARAMETER); ACE_TRY_CHECK; - orb->destroy (TAO_ENV_SINGLE_ARG_PARAMETER); + orb->destroy (ACE_ENV_SINGLE_ARG_PARAMETER); ACE_TRY_CHECK; } ACE_CATCHANY |