diff options
Diffstat (limited to 'TAO/performance-tests')
165 files changed, 32713 insertions, 0 deletions
diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/Makefile b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/Makefile new file mode 100644 index 00000000000..8a1b18e7113 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/Makefile @@ -0,0 +1,144 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the CHORUS COOL Cubit tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +IDL_SRC = cubit.cpp cubit.H sk_cubit.C sk_cubit.H + +SRC = $(IDL_SRC) cubit_i.cpp server.cpp client.cpp tmplinst.cpp + +SVR_OBJS = cubit_i.o server.o cubit.o tmplinst.o + +CLT_OBJS = client.o cubit.o tmplinst.o + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU +include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#---------------------------------------------------------------------------- +# CHORUS related macros and target settings. +#---------------------------------------------------------------------------- + +CHORUS_BINDIR = $(CHORUS_ROOT)/bin +CHORUS_LIBDIR = $(CHORUS_ROOT)/lib +CHORUS_INCDIR = $(CHORUS_ROOT)/include + +CPPFLAGS += -I$(CHORUS_INCDIR) -I$(CHORUS_ROOT) +LDFLAGS += -L$(CHORUS_LIBDIR) -R$(CHORUS_LIBDIR) -L$(ACE)/ace +IDLFLAGS = --stub-header --stub-impl --skeleton-header --skeleton-impl --no-local --binding Cubit Cubit_i --binding Cubit_Factory Cubit_Factory_i + +ifdef CHORUS + LDLIBS += -lOrb +else + LDLIBS += -lOrb-mt $(MATHLIB) +endif + +VLDLIBS := $(LDLIBS:%=%$(VAR)) $(ACELIB) $(LIBS) + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +all: $(IDL_SRC) server client + +$(IDL_SRC): cubit.idl + $(CHORUS_BINDIR)/chic $(IDLFLAGS) cubit.idl + -/bin/mv cubit.C cubit.cpp + +server: $(addprefix $(VDIR),$(SVR_OBJS)) + $(LINK.cc) -o server $(addprefix $(VDIR),$(SVR_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITSRV) $(VLDLIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CLT_OBJS)) + $(LINK.cc) -o client $(addprefix $(VDIR),$(CLT_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITCLT) $(VLDLIBS) $(POSTLINK) + +realclean: clean + -/bin/rm -rf cubit.cpp cubit.H sk_cubit.C sk_cubit.H server client + +#---------------------------------------------------------------------------- +# Dependencies +#---------------------------------------------------------------------------- +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubit.o .obj/cubit.so .shobj/cubit.o .shobj/cubit.so: cubit.cpp cubit.H +.obj/sk_cubit.o .obj/sk_cubit.so .shobj/sk_cubit.o .shobj/sk_cubit.so: sk_cubit.C +.obj/cubit_i.o .obj/cubit_i.so .shobj/cubit_i.o .shobj/cubit_i.so: cubit_i.cpp cubit_i.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Version.h \ + $(ACE_ROOT)/ace/ACE.i cubit.H sk_cubit.H +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Version.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Get_Opt.i cubit_i.h cubit.H \ + sk_cubit.H sk_cubit.C +.obj/client.o .obj/client.so .shobj/client.o .shobj/client.so: client.cpp \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Version.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + $(ACE_ROOT)/ace/Env_Value_T.h \ + $(ACE_ROOT)/ace/Env_Value_T.i client.h \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i cubit.H \ + /project/doc/miniCOOL/minicool.r4.3/solaris2.5-CC-mt/include/corba/cool.H \ + /project/doc/miniCOOL/minicool.r4.3/solaris2.5-CC-mt/include/api/api.H \ + sk_cubit.H +.obj/tmplinst.o .obj/tmplinst.so .shobj/tmplinst.o .shobj/tmplinst.so: tmplinst.cpp cubit.H \ + /project/doc/miniCOOL/minicool.r4.3/solaris2.5-CC-mt/include/corba/cool.H + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/README b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/README new file mode 100644 index 00000000000..5987e0d6df2 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/README @@ -0,0 +1,34 @@ +This is the cubit example that uses the TAO IDL compiler to generate +the stubs and skeletons. Additional features include presence of a +factory to create Cubit objects and testing the _bind call to get the +factory object reference. + +You can either run the server in the background in the same window as +the client or open a separate window for the client and server. + +server: +------- + +% server [-d] [-ORBhost <serverhost>] [-ORBport <portnum>] + [-n <number-of-cubit-objects>] + +The server cubit factory maintained num_of_cubit objects (default = +1). They are assigned keys that look like "key0", "key1", ... + +When the server is started and you have used the -d flag, you should +see as the first line of output something that looks like + iiop:1.0//serverhost:10013/factory (using -ORBobjrefstyle url) +or + IOR:000000000000001649444c3a43756269745... (using default -ORBobjrefstyle ior) + +Using -d turns on debugging messages. It is additive, i.e., the more +-d options provided, the more debugging you can get. At the moment, +only 2 levels of debugging are implemented, and more than 2 -d options +are ignored. + +client: +------- + +% client [-d] -h <hostname> -p <port> -k <cubit key> -n <iterations> + +cubit_key corresponds to "key0", "key1", ... diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/client.cpp b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/client.cpp new file mode 100644 index 00000000000..2fc718168c6 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/client.cpp @@ -0,0 +1,749 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// clnt.cpp +// +// = DESCRIPTION +// This class implements a simple "cube" CORBA client for the Cubit +// example using stubs generated by the TAO ORB IDL compiler. +// +// = AUTHORS +// Copyright 1994-1995 by Sun Microsystems Inc. +// and +// Aniruddha Gokhale, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "ace/Profile_Timer.h" +#include "ace/Env_Value_T.h" +#include "client.h" + +#include "api/api.H" +#include "cubit.H" +#include "sk_cubit.H" + +ACE_RCSID(IDL_Cubit, client, "$Id$") + +// Constants +u_int _debug_level = 0; +const u_int DEFAULT_PORT = 3000; +CORBA::Environment Cubit_Client::env_; + + +// Constructor. + +#define quote(x) #x + +Cubit_Client::Cubit_Client (void) + : cubit_factory_key_ ("factory"), + cubit_key_ ("key0"), + hostname_ (ACE_DEFAULT_SERVER_HOST), + loop_count_ (250), + exit_later_ (0), + factory_ (Cubit_Factory::_nil ()), + objref_ (CORBA::Object::_nil ()), + cubit_ (Cubit::_nil ()), + orb_ptr_ (0), + call_count_ (0), + error_count_ (0), + portnum_(DEFAULT_PORT) +{ +} + +// Simple function that returns the substraction of 117 from the +// parameter. + +int +Cubit_Client::func (u_int i) +{ + return i - 117; +} + +// Parses the command line arguments and returns an error status. + +int +Cubit_Client::parse_args (void) +{ + ACE_Get_Opt get_opts (argc_, argv_, "dn:h:p:k:x"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'd': // debug flag + _debug_level++; + break; + case 'n': // loop count + loop_count_ = (u_int) ACE_OS::atoi (get_opts.optarg); + break; + case 'h': + hostname_ = ACE_OS::strdup (get_opts.optarg); + break; + case 'p': + portnum_ = ACE_OS::atoi (get_opts.optarg); + break; + case 'k': // stringified objref + cubit_key_ = ACE_OS::strdup (get_opts.optarg); + break; + case 'x': + this->exit_later_++; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-d]" + " [-n loopcount]" + " [-k cubit-obj-ref-key]" + " [-h hostname]" + " [-p port]" + " [-x]" + "\n", + this->argv_ [0]), + -1); + } + + // Indicates successful parsing of command line. + return 0; +} + +// Exercise the union. Cube a union. + +void +Cubit_Client::cube_union_stub (void) +{ + CORBA::Environment env; + Cubit::oneof u, r; + + this->call_count_++; + + u.l (3); // use the long union branch + + // Cube a "union" ... + r = this->cubit_->cube_union (u, this->env_); + + if (this->env_.exception () != 0) + { + this->print_exception ("from cube_union"); + this->error_count_++; + } + else + { + if (_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "cube union ...")); + u.l (u.l () * u.l () * u.l ()) ; + + if (u.l () != r.l ()) + { + ACE_DEBUG ((LM_DEBUG, "** cube_union ERROR\n")); + this->error_count_++; + } + + } + + this->call_count_++; + + u._d (Cubit::e_3rd); +#if 0 + u.cm ().l = this->func (i); + u.cm ().s = this->func (i); + u.cm ().o = this->func (i); +#endif + + u.cm ().l = 7; + u.cm ().s = 5; + u.cm ().o = 3; + + // Cube another "union" which uses the default arm ... NOT tested yet + r = this->cubit_->cube_union (u, this->env_); + + if (this->env_.exception () != 0) + { + this->print_exception ("from cube_union"); + this->error_count_++; + } + else + { + if (_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "cube union ...")); + u.cm ().l = u.cm ().l * u.cm ().l * u.cm ().l; + u.cm ().s = u.cm ().s * u.cm ().s * u.cm ().s; + u.cm ().o = u.cm ().o * u.cm ().o * u.cm ().o; + + if (u.cm ().l != r.cm ().l + || u.cm ().s != r.cm ().s + || u.cm ().o != r.cm ().o) + { + ACE_DEBUG ((LM_DEBUG, "** cube_union ERROR\n")); + this->error_count_++; + } + } +} + +// Exercise the union using dii. + +void +Cubit_Client::cube_union_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req; + + this->call_count_++; + + req = this->cubit_->_request ((CORBA::String) "cube_union", this->env_); + + if (this->env_.exception () != 0) + { + this->error_count_++; + + this->print_exception ("cube_union_dii request create"); + return; + } + + // ... initialise the argument list and result ... + Cubit::oneof *u, r; + + u = new Cubit::oneof; + u->_d (Cubit::e_3rd); + + u->cm ().l = 5; + u->cm ().s = -7; + u->cm ().o = 3; + + CORBA::Any tmp_arg (Cubit::_tc_oneof, u, CORBA_FALSE); + + req->arguments ()->add_value ("values", tmp_arg, CORBA_ARG_IN, this->env_); + + if (this->env_.exception () != 0) + { + this->error_count_++; + this->print_exception ("cube_union_dii request arg add"); + CORBA::release (req); + return; + } + + req->result ()->value ()->replace (Cubit::_tc_oneof, 0, CORBA_TRUE); + + if (this->env_.exception () != 0) + { + this->error_count_++; + this->print_exception ("cube_union_dii result type"); + CORBA::release (req); + return; + } + + // Make the invocation, verify the result. + + req->invoke (); + + if (req->env ()->exception () != 0) + { + this->error_count_++; + this->print_exception ("cube_union_dii invoke", *req->env ()); + CORBA::release (req); + return; + } + + r = *(Cubit::oneof *) req->result ()->value ()->value (); + + if (r.cm ().o != 27 || r.cm ().l != 125 || r.cm ().s != -343) + { + this->error_count_++; + ACE_ERROR ((LM_ERROR, "cube_union_dii -- bad results\n")); + } + else + ACE_DEBUG ((LM_DEBUG, "cube_union_dii ... success!!")); + + CORBA::release (req); + delete u; +} + +// Cube a short. + +void +Cubit_Client::cube_short (int i) +{ + CORBA::Short arg_short = this->func (i); + // Cube a short. + CORBA::Short ret_short = cubit_->cube_short (arg_short, this->env_); + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->print_exception ("from cube_short"); + this->error_count_++; + } + else + { + if (_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "cube short: %d --> %d\n", + arg_short, + ret_short)); + arg_short = arg_short * arg_short * arg_short; + + if (arg_short != ret_short) + { + ACE_ERROR ((LM_ERROR, "** cube_short (%d) ERROR (--> %d)\n", + (CORBA::Short) this->func (i), + ret_short)); + this->error_count_++; + } + } +} + +// Cube an octet + +void +Cubit_Client::cube_octet (int i) +{ + CORBA::Octet arg_octet = this->func (i); + + // Cube an octet. + CORBA::Octet ret_octet = this->cubit_->cube_octet (arg_octet, this->env_); + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->print_exception ("from cube_octet"); + this->error_count_++; + } + else + { + if (_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "cube octet: %d --> %d\n", arg_octet, ret_octet)); + arg_octet = arg_octet * arg_octet * arg_octet; + if (arg_octet != ret_octet) { + ACE_DEBUG ((LM_DEBUG, + "** cube_octet (%d) ERROR (--> %d)\n", + (CORBA::Octet) this->func (i), + ret_octet)); + this->error_count_++; + } + } +} + +// calculate the cube from a long + +void +Cubit_Client::cube_long (int i) +{ + CORBA::Long arg_long = this->func (i); + + // Cube a long. + CORBA::Long ret_long = this->cubit_->cube_long (arg_long, this->env_);; + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->print_exception ("from cube_long"); + this->error_count_++; + } + else + { + if (_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "cube long: %d --> %d\n", arg_long, ret_long)); + arg_long = arg_long * arg_long * arg_long; + if (arg_long != ret_long) { + ACE_ERROR ((LM_ERROR, + "** cube_long (%ld) ERROR (--> %ld)\n", + (CORBA::Long) this->func (i), + ret_long)); + this->error_count_++; + } + } +} + +// Cube the numbers in a struct + +void +Cubit_Client::cube_struct (int i) +{ + Cubit::Many arg_struct; + Cubit::Many ret_struct; + + this->call_count_++; + + arg_struct.l = this->func (i); + arg_struct.s = this->func (i); + arg_struct.o = this->func (i); + + // Cube a "struct" ... + ret_struct = this->cubit_->cube_struct (arg_struct, this->env_); + + if (this->env_.exception () != 0) + { + this->print_exception ("from cube_struct"); + this->error_count_++; + } + else + { + if (_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, "cube struct ...")); + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o) + { + ACE_ERROR ((LM_ERROR, "** cube_struct ERROR\n")); + this->error_count_++; + } + } +} + +// Cube the numbers in a struct + +void +Cubit_Client::cube_struct_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req = + this->cubit_->_request ((CORBA::String) "cube_struct", this->env_); + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->print_exception ("DII request create"); + return; + } + + // ... initialise the argument list and result ... + Cubit::Many arg; + Cubit::Many result; + + arg.o = 3; + arg.l = 5; + arg.s = -7; + + CORBA::Any tmp_arg (Cubit::_tc_Many, &arg, CORBA_FALSE); + + req->arguments ()->add_value ("values", tmp_arg, CORBA_ARG_IN, this->env_); + + if (this->env_.exception () != 0) + { + this->print_exception ("DII request arg add"); + CORBA::release (req); + return; + } + + req->result ()->value ()->replace (Cubit::_tc_Many, 0, CORBA_TRUE); + + if (this->env_.exception () != 0) + { + this->print_exception ("DII request result type"); + CORBA::release (req); + return; + } + + // Make the invocation, verify the result + + req->invoke (); + + if (req->env ()->exception () != 0) + { + this->print_exception ("DII invoke sending struct", *req->env ()); + CORBA::release (req); + return; + } + + result = *(Cubit::Many *) req->result ()->value ()->value (); + + if (result.o != 27 || result.l != 125 || result.s != -343) + ACE_ERROR ((LM_ERROR, "DII cube_struct -- bad results\n")); + else + ACE_DEBUG ((LM_DEBUG, "DII cube_struct ... success!!")); + + CORBA::release (req); +} + +void +Cubit_Client::print_stats (const char *call_name, ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time) +{ + double tmp; + + ACE_DEBUG ((LM_DEBUG, + "%s:\n", + call_name)); + + if (this->call_count_ > 0 && this->error_count_ == 0) + { + tmp = 1000 / elapsed_time.real_time; + + elapsed_time.real_time *= ACE_ONE_SECOND_IN_MSECS; + elapsed_time.user_time *= ACE_ONE_SECOND_IN_MSECS; + elapsed_time.system_time *= ACE_ONE_SECOND_IN_MSECS; + + elapsed_time.real_time /= this->call_count_; + elapsed_time.user_time /= this->call_count_; + elapsed_time.system_time /= this->call_count_; + + tmp = 1000 / elapsed_time.real_time; + + ACE_DEBUG ((LM_DEBUG, + "\treal_time\t= %0.06f ms, \n\t" + "user_time\t= %0.06f ms, \n\t" + "system_time\t= %0.06f ms\n" + "\t%0.00f calls/second\n", + elapsed_time.real_time < 0.0? 0.0:elapsed_time.real_time, + elapsed_time.user_time < 0.0? 0.0:elapsed_time.user_time, + elapsed_time.system_time < 0.0? 0.0:elapsed_time.system_time, + tmp < 0.0? 0.0 : tmp)); + } + else + { + ACE_ERROR ((LM_ERROR, "\tNo time stats printed. Call count zero or error ocurred.\n")); + } + + ACE_DEBUG ((LM_DEBUG, + "\t%d calls, %d errors\n", + this->call_count_, + this->error_count_)); +} + +// Execute client example code. + +int +Cubit_Client::run (void) +{ + u_int i; + + ACE_Profile_Timer timer; + ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time; + + // ACE_Time_Value before; + + // We start an ACE_Profile_Timer here... + timer.start (); + + // Make the calls in a loop. + for (i = 0; i < this->loop_count_; i++) + { + this->cube_short (i); + this->cube_octet (i); + this->cube_long (i); + this->cube_struct (i); + } + + // stop the timer. + timer.stop (); + + timer.elapsed_time (elapsed_time); + // compute call average call time. + this->print_stats ("cube average call", elapsed_time); + + +#if 0 // this test is segfaulting, comment for now. + // Simple test for DII: call "cube_struct". (It's not timed since + // the copious mallocation of DII would bias numbers against typical + // stub-based calls). + + timer.start (); + + this->call_count_ = 0; + this->error_count_ = 0; + // Make the calls in a loop. + for (i = 0; i < this->loop_count_; i++) + { + this->cube_struct_dii (); + } + timer.stop (); + + timer.elapsed_time (elapsed_time); + // compute call average call time. + this->print_stats ("cube_struct_dii call", elapsed_time); + + // ------------------> + // Two more tests, using the "cube_union" function + + // unions using stubs + timer.start (); + + this->call_count_ = 0; + this->error_count_ = 0; + // Make the calls in a loop. + for (i = 0; i < this->loop_count_; i++) + { + this->cube_union_stub (); + } + + timer.stop (); + + timer.elapsed_time (elapsed_time); + // compute call average call time. + this->print_stats ("cube_union_stub call", elapsed_time); + + // union DII + timer.start (); + + this->call_count_ = 0; + this->error_count_ = 0; + // Make the calls in a loop. + for (i = 0; i < this->loop_count_; i++) + { + this->cube_union_dii (); + } + + timer.stop (); + + timer.elapsed_time (elapsed_time); + // compute call average call time. + this->print_stats ("cube_union_dii call", elapsed_time); +#endif + if (this->exit_later_) + { + this->cubit_->please_exit (this->env_); + this->print_exception ("server, please ACE_OS::exit", this->env_); + } + + return this->error_count_ == 0 ? 0 : 1; +} + +Cubit_Client::~Cubit_Client (void) +{ + // Free resources + CORBA::release (this->factory_); + CORBA::release (this->cubit_); +} + +int +Cubit_Client::init (int argc, char **argv) +{ + this->argc_ = argc; + this->argv_ = argv; + + // Retrieve the ORB. + this->orb_ptr_ = CORBA::ORB_init (this->argc_, + this->argv_, + 0, + this->env_); + + // Parse command line and verify parameters. + if (this->parse_args () == -1) + return -1; + + if (this->env_.exception () != 0) + { + this->print_exception ("ORB initialization"); + return -1; + } + + if (this->cubit_key_ == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "%s: must specify an object reference using -k <key>\n", + this->argv_[0]), + -1); + + // Retrieve a factory objref. + char ior[BUFSIZ]; + sprintf ( ior, "cool-tcp://%s:%d", this->hostname_, this->portnum_ ); + + ACE_DEBUG ((LM_DEBUG, "ior is \"%s\"\n", ior)); + + COOL::EOABindingData bindingData (ior); + + this->factory_ = Cubit_Factory::_bind(bindingData, this->env_); + + // this->objref_ = Cubit_Factory::_bind (this->hostname_, + // this->portnum_, + // this->cubit_factory_key_, + // this->env_); + + if (this->env_.exception () != 0) + { + this->print_exception ("Cubit_Factory::_bind"); + return -1; + } + + if (CORBA::is_nil (this->factory_) == CORBA_TRUE) + ACE_ERROR_RETURN ((LM_ERROR, + " _bind returned null object for host (%s), port (%d)\n", + this->hostname_, + this->portnum_), + -1); + + // Narrow the CORBA::Object reference to the stub object, checking + // the type along the way using _is_a. There is really no need to + // narrow <objref> because <_bind> will return us the + // <Cubit_Factory> pointer. However, we do it so that we can + // explicitly test the _narrow function. + +//this->factory_ = Cubit_Factory::_narrow (this->objref_, this->env_); + + //CORBA::release (this->objref_); + // this->objref_->Release (); + + // if (this->factory_ == 0) + // ACE_ERROR_RETURN ((LM_ERROR, + // " (%P|%t) Unable to narrow object reference to a Cubit_Factory_ptr.\n"), + // -1); + + // Now retrieve the Cubit obj ref corresponding to the key. + this->cubit_ = + this->factory_->make_cubit (this->cubit_key_, this->env_); + + if (this->env_.exception () != 0) + { + this->print_exception ("make_cubit"); + return -1; + } + + if (CORBA::is_nil (this->cubit_)) + ACE_ERROR_RETURN ((LM_ERROR, + "null cubit objref returned by factory\n"), + -1); + + return 0; +} + +void Cubit_Client::print_exception (const char * str, + const CORBA_Environment &env) +{ + CORBA::SystemException* ex; + + ex = CORBA::SystemException::_narrow(env.exception()); + + if (ex) + { + CORBA::String_var msg = ex->message(); + fprintf(stderr, "%s: %s.\n", str, (const char *) msg); + } + else + { + fprintf(stderr, "%s: Unknown user exception.\n", str); + } +} + + + + +// This function runs the test. + +int +main (int argc, char **argv) +{ + Cubit_Client cubit_client; + + if (cubit_client.init (argc, argv) == -1) + return 1; + else + return cubit_client.run (); +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) +template class ACE_Env_Value<unsigned long>; +template class ACE_Env_Value<unsigned short>; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +#pragma instantiate ACE_Env_Value<unsigned long> +#pragma instantiate ACE_Env_Value<unsigned short> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/client.h b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/client.h new file mode 100644 index 00000000000..94cc36a14bd --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/client.h @@ -0,0 +1,128 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// clnt.h +// +// = DESCRIPTION +// This class implements a simple "cube" CORBA client for the Cubit +// example using stubs generated by the TAO ORB IDL compiler. +// +// = AUTHORS +// Copyright 1994-1995 by Sun Microsystems Inc. +// and +// Aniruddha Gokhale, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "ace/Get_Opt.h" +#include "cubit.H" + +class Cubit_Client + // = TITLE + // Defines a class that encapsulates behaviour of the Cubit client + // example. Provides a better understanding of the logic in an + // object oriented way. + // + // = DESCRIPTION + // This class declares an interface to run the example client for + // Cubit CORBA server. All the complexity for initializing the + // server is hidden in the class. Just the run() interface is needed. +{ +public: + // = Constructor and destructor. + Cubit_Client (void); + ~Cubit_Client (void); + + int run (void); + // Execute client example code. + + int init (int argc, char **argv); + // Initialize the client communication endpoint with server. + + void print_exception (const char * str, + const CORBA_Environment &env=Cubit_Client::env_); + +private: + int func (u_int i); + // simple function that returns the substraction of 117 from the parameter. + + int parse_args (void); + // Parses the arguments passed on the command line. + + void print_stats (const char *call_name, ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time); + // prints the time stats + + void cube_union_stub (void); + // Exercise the union. Cube a union. + + void cube_union_dii (void); + // Exercise the union using dii. + + void cube_struct (int i); + // calculate the cube from a struct. + + void cube_long (int i); + // calculate the cube from a long + + void cube_octet (int i); + // Cube an octet + + void cube_short (int i); + // Cube a short. + + void cube_sequence (int i); + // Cube a sequence. + + void cube_struct_dii (void); + // Cube the numbers in a struct + + int argc_; + // # of arguments on the command line. + + char **argv_; + // arguments from command line. + + const char *cubit_factory_key_; + // Key of factory obj ref. + + char *cubit_key_; + // Key of the obj ref to be retrieved via the factory. + + char *hostname_; + // Hostname of server. + + CORBA::UShort portnum_; + // default port number of server. + + u_int loop_count_; + // Number of times to do the cube operations. + + int exit_later_; + // Flag to tell server to not exit immediately + + Cubit_Factory_ptr factory_; + // factory pointer for cubit. + + CORBA::Object_ptr objref_; + // storage of the factory objref + + static CORBA::Environment env_; + // Environment variable + + Cubit_ptr cubit_; + // Cubit obj ref + + CORBA::ORB_ptr orb_ptr_; + // Remember our orb + + u_int call_count_; + // # of calls made to functions + + u_int error_count_; + // # of errors incurred in the lifetime of the application. +}; diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit.idl b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit.idl new file mode 100644 index 00000000000..9ddc2d8954f --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit.idl @@ -0,0 +1,71 @@ +// $Id$ + +interface Cubit + // = TITLE + // Defines an interface that encapsulates operations that cube + // numbers. + // + // = DESCRIPTION + // This interface encapsulates operations that cube + // octets, shorts, longs, structs and unions. + +{ + octet cube_octet (in octet o); + // cube an octet + + short cube_short (in short s); + // cube a short + + long cube_long (in long l); + // cube a long + + struct Many + { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + // Cube a struct + + enum discrim + { + e_0th, + e_1st, + e_2nd, + e_3rd + }; + // Enumeration of the different elements in a union. + + union oneof switch (discrim) + { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + Many cm; + + // default: + // Many cm; + }; + // Union of different types. + + oneof cube_union (in oneof values); + // cube a union. + + oneway void please_exit (); + // shutdown the application. +}; + +interface Cubit_Factory + // = TITLE + // Creates Cubit objects +{ + Cubit make_cubit (in string key); +}; diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit_i.cpp b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit_i.cpp new file mode 100644 index 00000000000..74ef088ee8e --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit_i.cpp @@ -0,0 +1,191 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// cubit_i.cpp +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "cubit_i.h" +#include <api/api.H> +#include <api/binding.H> +#include <corba/eoa.H> +#include <corba/eorb.H> + +ACE_RCSID(IDL_Cubit, cubit_i, "$Id$") + +extern void print_exception (const CORBA_Environment &env, const char * str); + +// Constructor + +Cubit_Factory_i::Cubit_Factory_i (const char *key, int numobjs) +{ + // Create implementation object with user specified key. + + this->numobjs_ = numobjs; + this->my_cubit_ = new Cubit_i_ptr [this->numobjs_]; + + static char obj_str [MAXNAMELEN]; + + for (u_int i = 0; i < this->numobjs_; i++) + { + ACE_OS::memset (obj_str, '\0', MAXNAMELEN); + ACE_OS::sprintf (obj_str, "key%d", i); + + my_cubit_[i] = new Cubit_i (obj_str); + + if (my_cubit_[i] == 0) + ACE_ERROR ((LM_ERROR, + " (%P|%t) Unable to create implementation object%d\n", + i)); + + } +} + +// Destructor + +Cubit_Factory_i::~Cubit_Factory_i (void) +{ + delete [] this->my_cubit_; +} + +Cubit_ptr +Cubit_Factory_i::make_cubit (const char *key, CORBA::Environment &env) +{ + Cubit_ptr cb = 0; + + for (size_t i = 0; i < this->numobjs_; i++) + { + const char *obj_str = this->my_cubit_[i]->_get_name (); + + // Keys matched. + if (!ACE_OS::strcmp (obj_str, key)) + { + COOL_bind(*(this->my_cubit_ [i]), cb, env); + if (env.exception() != 0) + print_exception (env, "COOL_bind"); + // return Cubit::_duplicate (this->my_cubit_ [i]); + return cb; + } + } + + return Cubit::_nil (); +} + +// Constructor + +Cubit_i::Cubit_i (const char *obj_name) + // : POA_Cubit (obj_name) +{ + obj_name_ = ACE_OS::strdup (obj_name); +} + +const char * +Cubit_i::_get_name (void) +{ + return this->obj_name_; +} + +// Destructor + +Cubit_i::~Cubit_i (void) +{ +} + +// Cube an octet + +CORBA::Octet +Cubit_i::cube_octet (CORBA::Octet o, + CORBA::Environment &env) +{ + ACE_UNUSED_ARG (env); + return o * o * o; +} + +// Cube a short. + +CORBA::Short +Cubit_i::cube_short (CORBA::Short s, + CORBA::Environment &env) +{ + ACE_UNUSED_ARG (env); + return s * s * s; +} + +// Cube a long + +CORBA::Long +Cubit_i::cube_long (CORBA::Long l, + CORBA::Environment &env) +{ + ACE_UNUSED_ARG (env); + return l * l * l; +} + +// Cube a struct + +Cubit::Many +Cubit_i::cube_struct (const Cubit::Many &values, + CORBA::Environment &env) +{ + Cubit::Many temp; + + ACE_UNUSED_ARG (env); + temp.o = values.o * values.o * values.o; + temp.s = values.s * values.s * values.s; + temp.l = values.l * values.l * values.l; + + return temp; +} + +// Cube a union + +Cubit::oneof +Cubit_i::cube_union (const Cubit::oneof &values, + CORBA::Environment &env) +{ + Cubit::oneof temp; + + ACE_UNUSED_ARG (env); + switch (values._d ()) + { + case Cubit::e_0th: + temp.o (values.o () * values.o () * values.o ()); + break; + case Cubit::e_1st: + temp.s (values.s () * values.s () * values.s ()); + break; + case Cubit::e_2nd: + temp.l (values.l () * values.l () * values.l ()); + break; + case Cubit::e_3rd: + default: + temp._d (values._d ()); // set the discriminant + // use the read/write accessor + temp.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o; + temp.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s; + temp.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l; + + } + return temp; +} + +// Shutdown. + +void Cubit_i::please_exit (CORBA::Environment &env) +{ + // Macro to avoid "warning: unused parameter" type warning. + ACE_UNUSED_ARG (env); + + ACE_DEBUG ((LM_DEBUG, "I've been asked to shut down...")); + thisCapsule->boa()->shutdown(); + + CORBA_BOA::deactivate_object(this, env); +} diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit_i.h b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit_i.h new file mode 100644 index 00000000000..9db23e7dbb6 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/cubit_i.h @@ -0,0 +1,109 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// cubit_i.h +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee and Sergio Flores-Gaitan +// +// ============================================================================ + +#if !defined (_CUBIT_I_HH) +#define _CUBIT_I_HH + +#include "ace/ACE.h" + +#include <api/api.H> +#include <api/binding.H> +#include <corba/eoa.H> +#include <corba/eorb.H> + +extern COOL_CurrentCapsule* thisCapsule; + +#include "cubit.H" +#include "sk_cubit.H" + +// Forward declarations +class Cubit_i; + +// Typedefs. +typedef Cubit_i *Cubit_i_ptr; +typedef Cubit_i_ptr Cubit_i_ref; + +class Cubit_i + // = TITLE + // Illustrates how to integrate a servant with the + // generated skeleton. + // = DESCRIPTION + // Implementation of the cubit example at the servant side. + // Cubes an octet, short, long, struct and union. +{ +public: + Cubit_i (const char *obj_name = 0); + // Constructor + + ~Cubit_i (void); + // Destructor + + virtual CORBA::Octet cube_octet (CORBA::Octet o, + CORBA::Environment &env); + // Cube an octet + + virtual CORBA::Short cube_short (CORBA::Short s, + CORBA::Environment &env); + // Cube a short + + virtual CORBA::Long cube_long (CORBA::Long l, + CORBA::Environment &env); + // Cube a long + + virtual Cubit::Many cube_struct (const Cubit::Many &values, + CORBA::Environment &env); + // Cube a struct. + + virtual Cubit::oneof cube_union (const Cubit::oneof &values, + CORBA::Environment &env); + // Cube a union. + + virtual void please_exit (CORBA::Environment &env); + // Shutdown routine. + + const char *_get_name (void); + + private: + const char * obj_name_; +}; + + +class Cubit_Factory_i; + +typedef Cubit_Factory_i *Cubit_Factory_i_ptr; + +class Cubit_Factory_i + // =TITLE + // Cubit_Factory_i + // + // DESCRIPTION + // factory object returning the cubit objrefs +{ +public: + Cubit_Factory_i (const char *key, int numobjs); + // constructor + + ~Cubit_Factory_i (void); + // destructor + + virtual Cubit_ptr make_cubit (const char *key, CORBA::Environment &env); + // make the cubit object whose key is "key" + +private: + Cubit_i_ptr *my_cubit_; + u_int numobjs_; +}; + +#endif /* _CUBIT_I_HH */ diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/server.cpp b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/server.cpp new file mode 100644 index 00000000000..242810c72a5 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/server.cpp @@ -0,0 +1,151 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// svr.cpp +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "ace/Get_Opt.h" +#include "ace/Log_Msg.h" + +#include "cubit_i.h" + +#include <api/binding.H> +#include <api/api.H> +#include "cubit.H" +#include "sk_cubit.H" +#include "sk_cubit.C" + +ACE_RCSID(IDL_Cubit, server, "$Id$") + +void print_exception (const CORBA_Environment &env, + const char * str) +{ + CORBA::SystemException* ex; + + ex = CORBA::SystemException::_narrow(env.exception()); + + if (ex) + { + CORBA::String_var msg = ex->message(); + fprintf(stderr, "%s: %s.\n", str, (const char *) msg); + } + else + { + fprintf(stderr, "Unknown user exception.\n"); + } +} + + +// Global Variables +static int num_of_objs = 1; + +u_int _debug_level = 0; + +// Parses the command line arguments and returns an error status + +static int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "dn:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'd': // debug flag + _debug_level++; + break; + case 'n': // number of cubit objects we hold + num_of_objs = ACE_OS::atoi (get_opts.optarg); + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-d]" + " [-n] <num of cubit objects>" + "\n", argv [0]), 1); + } + + return 0; // Indicates successful parsing of command line +} + +// Standard command line parsing utilities used. + +int +main (int argc, char *argv[]) +{ + CORBA::Environment env; + + COOL::EOA::bind(argv[1], env); + if (env.exception()) { + ACE_DEBUG ((LM_ERROR, "Impossible to bind the ORB to the description:%s\n", argv[1])); + return -1; + } + + CORBA::ORB_ptr orb_ptr = CORBA::ORB_init (argc, argv, 0, env); + + if (env.exception () != 0) + { + print_exception (env, "ORB init"); + return 1; + } + + // Initialize the Object Adapter + CORBA_BOA_ptr oa_ptr = orb_ptr->OA_init (argc, argv, 0, env); + + if (env.exception() != 0) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize the POA.\n"), + 1); + + // Parse remaining command line and verify parameters. + parse_args (argc, argv); + + // create a factory implementation + Cubit_Factory_ptr factory; + Cubit_Factory_i *factory_i; + COOL::EOABindingData bindingData; + + ACE_NEW_RETURN (factory_i, Cubit_Factory_i ("factory", num_of_objs), 1); + + COOL_bind (*factory_i, factory, bindingData, env); + + if (_debug_level > 0) + { + // Stringify the objref we'll be implementing, and print it to + // stdout. Someone will take that string and give it to a + // client. Then release the object. + + CORBA::String str; + + str = orb_ptr->object_to_string (factory, env); + + if (env.exception () != 0) + { + print_exception (env, "object_to_string"); + return -1; + } + + ACE_OS::puts ((char *) str); + ACE_OS::fflush (stdout); + + ACE_DEBUG ((LM_DEBUG, "listening as object '%s'\n", str)); + } + + // Handle requests for this object until we're killed, or one of the + // methods asks us to exit. + ACE_DEBUG ((LM_DEBUG, "Entering boa->run ().\n")); + oa_ptr->run (); + + return 0; +} diff --git a/TAO/performance-tests/Cubit/COOL/IDL_Cubit/tmplinst.cpp b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/tmplinst.cpp new file mode 100644 index 00000000000..0a3fd6572db --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/IDL_Cubit/tmplinst.cpp @@ -0,0 +1,17 @@ +// +// $Id$ +// + +// The contents of this file REALLY should be generated by the IDL +// compiler, but that functionality isn't available yet. + +#include "cubit.H" + +ACE_RCSID(IDL_Cubit, tmplinst, "$Id$") + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) +template class TAO_Unbounded_Sequence<long>; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +#pragma instantiate TAO_Unbounded_Sequence<long> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/Makefile b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Makefile new file mode 100644 index 00000000000..d605120ca98 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Makefile @@ -0,0 +1,91 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the CHORUS COOL Cubit tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +IDL_SRC = cubit.cpp cubit.H sk_cubit.C sk_cubit.H + +SRC = $(IDL_SRC) \ + cubit_impl.cpp \ + server.cpp \ + client.cpp \ + Task_Client.cpp \ + Util_Thread.cpp + +SVR_OBJS = cubit_impl.o \ + server.o \ + cubit.o + +CLT_OBJS = Task_Client.o \ + client.o \ + cubit.o \ + Util_Thread.o + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU +include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#---------------------------------------------------------------------------- +# CHORUS related macros and target settings. +#---------------------------------------------------------------------------- + +CHORUS_BINDIR = $(CHORUS_ROOT)/bin +CHORUS_LIBDIR = $(CHORUS_ROOT)/lib +CHORUS_INCDIR = $(CHORUS_ROOT)/include + +CPPFLAGS += -I$(CHORUS_INCDIR) -I$(CHORUS_ROOT) +LDFLAGS += -L$(CHORUS_LIBDIR) -R$(CHORUS_LIBDIR) -L$(ACE)/ace +IDLFLAGS = --stub-header --stub-impl --skeleton-header --skeleton-impl --no-local --no-any --binding Cubit Cubit_Impl + +# pccTimer will eventually get integrated into ACE. It is specific for +# ClassiX on VME +ifdef CHORUS + SRC += pccTimer.cpp + CLT_OBJS += pccTimer.o + LDLIBS += -lOrb +else + LDLIBS += -lOrb-mt +endif + +VLDLIBS := $(LDLIBS:%=%$(VAR)) $(ACELIB) $(LIBS) + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +all: $(IDL_SRC) server client + +$(IDL_SRC): cubit.idl + $(CHORUS_BINDIR)/chic $(IDLFLAGS) cubit.idl + -/bin/mv cubit.C cubit.cpp + +server: $(addprefix $(VDIR),$(SVR_OBJS)) + $(LINK.cc) -o server $(addprefix $(VDIR),$(SVR_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITSRV) $(VLDLIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CLT_OBJS)) + $(LINK.cc) -o client $(addprefix $(VDIR),$(CLT_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITCLT) $(VLDLIBS) $(POSTLINK) + +realclean: clean + -/bin/rm -rf cubit.cpp cubit.H sk_cubit.C sk_cubit.H server client + +#---------------------------------------------------------------------------- +# Dependencies +#---------------------------------------------------------------------------- +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/README b/TAO/performance-tests/Cubit/COOL/MT_Cubit/README new file mode 100644 index 00000000000..f8e7941cbdf --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/README @@ -0,0 +1,166 @@ +The MT-Cubit example for the CHORUS COOL ORB +-------------------------------------------- + +Compiling +--------- + +Setup the CHORUS COOL environment variables before compiling, the +following is an example. You would typically want this in the shells' +resource file (e.g. .cshrc.mine). The example provided is for a C +shell. + + setenv CHORUS_ROOT /project/doc/miniCOOL/minicool.r4.3/solaris2.5-CC-mt + set path = ($path /project/doc/miniCOOL/minicool.r4.3/solaris2.5-CC-mt/bin) + setenv LD_LIBRARY_PATH /project/doc/miniCOOL/minicool.r4.3/solaris2.5-CC-mt/lib:$LD_LIBRARY_PATH + setenv MANPATH /project/doc/miniCOOL/minicool.r4.3/solaris2.5-CC-mt/man:$MANPATH + +Makefiles are provided. Use make to compile. + +You can either run the server in the background in the same window as +the client or open a separate window for the client and server. + +server: +------- + +./server <tpr | tpool> + <cool-tcp://THIS_HOSTNAME:THIS_HOST_PORT | cool-chorus://:THIS_HOST_PORT> + -v + <-cool-tcp -cool-iiop | -cool-chorus> + +tpr : this indicates to the server to use the Thread Per Request concurrency model. + +tpool : this indicates to the server to use the Thread Pool concurrency model. + +THIS_HOSTNAME : the name of the host that the server will be running on. This is useful + if you want to specifya different interface (e.g. ATM, 100Mbit Ethernet) + +THIS_HOST_PORT: is the port number at which the server will start the high + priority servant. The low priority servant will be created at + (THIS_HOST_PORT+1). + +The server will print the IOR of the high and low priority servants, +but it is not required by the client. + +client: +------- + +./client [-n <LOOP_COUNT>] + [-t <NUM_THREADS>] + [-h SERVER_HOSTNAME] + [-p <SERVER_PORT_NUM>] + [-cool-tcp -cool-iiop | -cool-chorus] + [-I] + +[-I] indicates to the client to use Chorus IPC as the underlying transport + instead of TCP + +<SERVER_HOSTNAME>: is the hostname of the server. + +<SERVER_PORT_NUM>: is the port number of the servant. + +Based on the SERVER_HOSTNAME and the SERVER_PORT_NUM, the client constructs +the IOR's for the high priority servant and the low priority servant. + +<LOOP_COUNT> : is the number of times the group of CORBA twoway calls are to + be made. The group consists of the following calls: cube_octet(), cube_short(), + cube_long() and cube_struct(). The default is 100 loops (i.e. 400 calls are made). + +<NUM_THREADS> : is the total number of concurrent clients to be + created. One of these clients will be a high priority client (and thus + send requests to the high priority servant), and the rest will have + low priority. + +The high priority client makes requests at 20Hz, and the low priority +clients make requests at 10Hz. + +Results +------- + +The client prints the latency observed by the high priority client, +and the average latency observed by the low priority client. + +Examples +-------- + +(1) An Example on a Sparc running SunOS 5.5.1 using TCP as the underlying transport + + + On the host lambada.cs.wustl.edu : + + % ./server tpool cool-tcp://lambada.cs.wustl.edu:3000 -v -cool-tcp -cool-iiop + + On the host merengue.cs.wustl.edu : + + % ./client -t 2 -h lambada.cs.wustl.edu -p 3000 -cool-tcp -cool-iiop + + The output of the client program may look like this: + + (5) Everyone's done, here I go!! + (4) Threads have bound, utilization test started + (9) Everyone's done, here I go!! + (8) Everyone's done, here I go!! + (6) Everyone's done, here I go!! + (7) Everyone's done, here I go!! + cube average call ACE_OS::time = 20.917016 msec, 47.807966 calls/second + (5) My latency was 20.917016 + 5 calls, 0 errors + cube average call ACE_OS::time = 19.299501 msec, 51.814811 calls/second + (8) My latency was 19.299501 + cube average call ACE_OS::time = 19.262436 msec, 51.914514 calls/second + 5 calls, 0 errors + (9) My latency was 19.262436 + 5 calls, 0 errors + cube average call ACE_OS::time = 15.101540 msec, 66.218412 calls/second + (6) My latency was 15.101540 + 5 calls, 0 errors + cube average call ACE_OS::time = 10.320359 msec, 96.895858 calls/second + (7) My latency was 10.320359 + 5 calls, 0 errors + Test done. + High priority client latency : 20.917016 msec, jitter: 36.582330 msec + Low priority client latency : 15.995959 msec, jitter: 527.515277 msec + utilization task performed 435 computations + +(2) An Example on a MVME177 backplane using 68k processors running ClassiX using + Chorus IPC as the underlying transport + + + On the host tambora2.cs.wustl.edu : + + % rsh tambora2 arun /tests/Cubit/COOL/MT_Cubit/server tpool cool-chorus://:1023 -v -cool-chorus + + On the host tambora1.cs.wustl.edu : + + % rsh tambora1 arun /tests/Cubit/COOL/MT_Cubit/client -n 400 -I -t 2 -p 1023 -cool-chorus + + The output of the client program might look like this: + + started aid = 12 + COOL:0000000001000000010000001C00750AA60000000200750AA65555555500000001429A00000000000A(13) Thread created + (13) Im the high priority client, my id is 0. + Using ior = cool-chorus://:1023 + Creating 1 clients with low priority of 125 + (13) Binding succeeded + (13) Cb == 2c6144 + Object Created at: '2908484l'connected to object 'COOL:0000000001000000010000001C00750AA60000000200750AA65555555500000001429A00000000000A' + COOL:0000000001000000010000001C00750AA60000000200750AA65555555500000001429A00000000000A + (13) Waiting for other threads to finish binding.. + (12) Thread created + (12) Im a low priority client, my id is 1 + Using ior = cool-chorus://:1023 + (12) Binding succeeded + (12) Cb == 2c6164 + Object Created at: '2908516l'connected to object 'COOL:0000000001000000010000001C00750AA60000000200750AA65555555500000001429A00000000000A'(12) Waiting for other threads to finish binding.. + (13) Everyone's done, here I go!! + (12) Everyone's done, here I go!! + (12|13) cube average call ACE_OS::time = 12835 usec, 77 calls/second + (13) My latency was 12835 + 400 calls, 0 errors + (12|12) cube average call ACE_OS::time = 12931 usec, 77 calls/second + (12) My latency was 12931 + Test done. + High priority client latency : 12835 usec + Low priority client latency : 12931 usec + 400 calls, 0 errors + --->Output file for latency data is "cb12__2.txt" + (8) utilization task performed 0 computations diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/Task_Client.cpp b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Task_Client.cpp new file mode 100644 index 00000000000..86db2f4e172 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Task_Client.cpp @@ -0,0 +1,629 @@ +// $Id$ + +#include "Task_Client.h" + +ACE_RCSID(MT_Cubit, Task_Client, "$Id$") + +Task_State::Task_State (int argc, char **argv) + : start_count_ (0), + loop_count_ (5), + thread_count_ (5), + base_port_ (5000), + datatype_ (CB_OCTET), + argc_ (argc), + argv_ (argv), + thread_per_rate_ (0), + global_jitter_array_ (0), + use_chorus_ipc_ (0), + grain_ (1) +{ + int c; + int datatype; + + // defaults + ACE_OS::strcpy (server_host_, "localhost"); + ior_header_ = ACE_OS::strdup ("cool-tcp"); + ACE_Get_Opt opts (argc, argv, "Hh:n:t:p:d:rIg:"); + + while ((c = opts ()) != -1) + switch (c) { + case 'g': + grain_ = ACE_OS::atoi (opts.optarg); + if (grain_ < 1) + grain_ = 1; + break; + case 'I': + use_chorus_ipc_ = 1; + break; + case 'r': + thread_per_rate_ = 1; + break; + case 'd': + datatype = ACE_OS::atoi (opts.optarg); + switch (datatype) + { + case CB_OCTET: + ACE_DEBUG ((LM_DEBUG, "Testing Octets\n")); + datatype_ = CB_OCTET; + break; + case CB_LONG: + ACE_DEBUG ((LM_DEBUG, "Testing Longs\n")); + datatype_ = CB_LONG; + break; + case CB_STRUCT: + ACE_DEBUG ((LM_DEBUG, "Testing Structs\n")); + datatype_ = CB_STRUCT; + break; + case CB_SHORT: + default: + ACE_DEBUG ((LM_DEBUG, "Testing Shorts\n")); + datatype_ = CB_SHORT; + break; + } + continue; + case 'h': + ACE_OS::strcpy (server_host_, opts.optarg); + continue; + case 'p': + base_port_ = ACE_OS::atoi (opts.optarg); + continue; + case 'n': // loop count + loop_count_ = (u_int) ACE_OS::atoi (opts.optarg); + continue; + case 't': + thread_count_ = (u_int) ACE_OS::atoi (opts.optarg); + continue; + case 'H': + ACE_DEBUG ((LM_DEBUG, "usage: %s" + "[-d datatype Octet=0, Short=1, Long=2, Struct=3]" + " [-n num_calls]" + " [-h server_hostname]" + " [-p server_port_num]" + " [-t num_threads]" + " [-I Use Chorus IPC. (For Chorus ClassiX *only*) ]" + " [-g granularity_of_request_timing]" + "\n", argv [0])); + continue; + } + + if (use_chorus_ipc_ == 1) + { + ior_header_ = ACE_OS::strdup ("cool-chorus"); + ACE_OS::strcpy (server_host_, ""); + } + + // thread_count_ + 1 because there is one utilization thread also + // wanting to begin at the same time the clients begin.. + ACE_NEW (barrier_, ACE_Barrier (thread_count_ + 1)); + ACE_NEW (latency_, double [thread_count_]); + ACE_NEW (global_jitter_array_, double *[thread_count_]); +} + +Client::Client (Task_State *ts) + : ACE_Task<ACE_MT_SYNCH> (ACE_Thread_Manager::instance ()), + ts_ (ts) +{ +} + +void +Client::put_latency (double *jitter, double latency, u_int thread_id) +{ + ACE_MT (ACE_GUARD (ACE_SYNCH_MUTEX, ace_mon, ts_->lock_)); + + ts_->latency_[thread_id] = latency; + ts_->global_jitter_array_ [thread_id] = jitter; + +#if defined (ACE_LACKS_FLOATING_POINT) + ACE_DEBUG ((LM_DEBUG, + "(%t) My latency was %u\n", + latency)); +#else + ACE_DEBUG ((LM_DEBUG, + "(%t) My latency was %f\n", + latency)); +#endif /* ! ACE_LACKS_FLOATING_POINT */ +} + +double +Client::get_high_priority_latency (void) +{ + return (double) ts_->latency_ [0]; +} + +double +Client::get_low_priority_latency (void) +{ + double l = 0; + + for (u_int i = 1; i < ts_->start_count_; i++) + l += (double) ts_->latency_[i]; + return ts_->start_count_ > 1? l / (double) (ts_->start_count_ - 1) : 0; +} + +int +Client::get_latency (u_int thread_id) +{ + return ts_->latency_ [thread_id]; +} + +double +Client::get_high_priority_jitter (void) +{ + double jitter = 0; + double average = get_high_priority_latency (); + + // Compute the standard deviation (i.e. jitter) from the values + // stored in the global_jitter_array_. + + // we first compute the sum of the squares of the differences + // each latency has from the average + for (u_int i = 0; i < ts_->loop_count_; i ++) + { + double difference = + ts_->global_jitter_array_ [0][i] - average; + jitter += difference * difference; + } + + // Return the square root of the sum of the differences computed + // above, i.e. jitter. + return sqrt (jitter); +} + +double +Client::get_low_priority_jitter (void) +{ + double jitter = 0; + double average = get_low_priority_latency (); + + // Compute the standard deviation (i.e. jitter) from the values + // stored in the global_jitter_array_. + + // We first compute the sum of the squares of the differences each + // latency has from the average. + for (u_int j = 1; j < ts_->start_count_; j ++) + for (u_int i = 0; i < ts_->loop_count_; i ++) + { + double difference = ts_->global_jitter_array_ [j][i] - average; + jitter += difference * difference; + } + + // Return the square root of the sum of the differences computed + // above, i.e. jitter. + return sqrt (jitter); +} + +int +Client::svc (void) +{ + ACE_DEBUG ((LM_DEBUG, + "(%t) Thread created\n")); + + u_int thread_id; + Cubit_ptr cb; + char ior [1024]; + double frequency; + CORBA::ORB_ptr orb_ptr; + + { + ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, ts_->lock_, -1); + + thread_id = ts_->start_count_; + ts_->start_count_++; + + if (ts_->thread_per_rate_ == 0) + { + if (thread_id == 0) + { + ACE_DEBUG ((LM_DEBUG, + "(%t) Im the high priority client, my id is %d.\n", + thread_id)); + ACE_OS::sprintf (ior, + "%s://%s:%d", + ts_->ior_header_, + ts_->server_host_, + ts_->base_port_); + frequency = CB_HIGH_PRIORITY_RATE; + } + else + { + ACE_DEBUG ((LM_DEBUG, + "(%t) Im a low priority client, my id is %d\n", + thread_id)); + ACE_OS::sprintf (ior, + "%s://%s:%d", + ts_->ior_header_, + ts_->server_host_, + ts_->base_port_);// + thread_id); + frequency = CB_LOW_PRIORITY_RATE; + } + } + else + { + switch (thread_id) + { +///////////////////////////////////// +// THIS NEEDS TO BE UPDATED AS ABOVE. +///////////////////////////////////// + case CB_40HZ_CONSUMER: + ACE_DEBUG ((LM_DEBUG, "(%t) Im the high priority client, my id is %d.\n", thread_id)); + ::sprintf (ior, "cool-tcp://%s:%d", ts_->server_host_, ts_->base_port_); + frequency = CB_40HZ_CONSUMER_RATE; + break; + case CB_20HZ_CONSUMER: + ACE_DEBUG ((LM_DEBUG, "(%t) Im the high priority client, my id is %d.\n", thread_id)); + ::sprintf (ior, "cool-tcp://%s:%d", ts_->server_host_, ts_->base_port_);//+1); + frequency = CB_20HZ_CONSUMER_RATE; + break; + case CB_10HZ_CONSUMER: + ACE_DEBUG ((LM_DEBUG, "(%t) Im the high priority client, my id is %d.\n", thread_id)); + ::sprintf (ior, "cool-tcp://%s:%d", ts_->server_host_, ts_->base_port_);//+2); + frequency = CB_10HZ_CONSUMER_RATE; + break; + case CB_5HZ_CONSUMER: + ACE_DEBUG ((LM_DEBUG, "(%t) Im the high priority client, my id is %d.\n", thread_id)); + ::sprintf (ior, "cool-tcp://%s:%d", ts_->server_host_, ts_->base_port_);//+3); + frequency = CB_5HZ_CONSUMER_RATE; + break; + case CB_1HZ_CONSUMER: + ACE_DEBUG ((LM_DEBUG, "(%t) Im the high priority client, my id is %d.\n", thread_id)); + ::sprintf (ior, "cool-tcp://%s:%d", ts_->server_host_, ts_->base_port_);//+4); + frequency = CB_1HZ_CONSUMER_RATE; + break; + default: + ACE_DEBUG ((LM_DEBUG, "(%t) Invalid Thread ID.\n", thread_id)); + } + } /* else */ + + ACE_DEBUG ((LM_DEBUG, "Using ior = %s\n", ior)); + + CORBA::Object_ptr objref = CORBA::Object::_nil (); + CORBA::Environment env; + + orb_ptr = CORBA::ORB_init (ts_->argc_, ts_->argv_, 0, env); + + if (env.exception () != 0) + ACE_ERROR_RETURN ((LM_ERROR,"%s:ORB initialization", env.exception ()), 2); + + // CORBA_BOA_ptr oa_ptr = orb_ptr->OA_init (ts_->argc_, ts_->argv_, 0, env); + // + // if (oa_ptr == 0) + // ACE_ERROR_RETURN ((LM_ERROR, + // " (%P|%t) Unable to initialize the POA.\n"), + // 1); + + + // + // Initialize client's binding to an + // arbitrary cubit server (at some host) + // + COOL::EOABindingData bindingData (ior); + + cb = Cubit::_bind(bindingData, env); + + // objref = orb_ptr->string_to_object ((CORBA::String) ior, env); + + // if (env.exception () != 0) + // ACE_ERROR_RETURN ((LM_ERROR, + // "%s:string2object failed. Supply valid IOR with the -O option\n", + // env.exception ()), 2); + + // if (CORBA::is_nil (objref) == CORBA_TRUE) + // ACE_ERROR_RETURN ((LM_ERROR, + // "%s: must identify non-null target objref\n", + // ts_->argv_ [0]), + // 1); + + // Narrow the CORBA::Object reference to the stub object, checking + // the type along the way using _is_a. + // cb = Cubit::_narrow (objref); + + if ( (CORBA::is_nil (cb) == CORBA_TRUE) || (env.exception () != 0)) + { + ACE_ERROR_RETURN ((LM_ERROR, "%s:Create cubit failed\n", env.exception ()), 1); + } + ACE_DEBUG ((LM_DEBUG, "(%t) Binding succeeded\n")); + ACE_DEBUG ((LM_DEBUG, "(%t) Cb == %x\n", cb)); + + CORBA::String str; + + str = orb_ptr->object_to_string (cb, env); + + if (env.exception () != 0) + ACE_ERROR_RETURN ((LM_ERROR, "object_to_string %s\n", env.exception ()), -1); + + ACE_OS::puts ((char *) str); + ACE_OS::fflush (stdout); + ACE_DEBUG ((LM_DEBUG, "Object Created at: '%ul'", cb)); + ACE_DEBUG ((LM_DEBUG, "connected to object '%s'", str)); + } + + ACE_DEBUG ((LM_DEBUG, "(%t) Waiting for other threads to finish binding..\n")); + ts_->barrier_->wait (); + ACE_DEBUG ((LM_DEBUG, "(%t) Everyone's done, here I go!!\n")); + + this->run_tests (cb, ts_->loop_count_, thread_id, ts_->datatype_, frequency); + + // Free resources + // CORBA::release (orb_ptr); + + return 0; +} + +int +Client::run_tests (Cubit_ptr cb, + u_int loop_count, + u_int thread_id, + Cubit_Datatypes datatype, + double frequency) +{ + CORBA::Environment env; + u_int i = 0; + u_int call_count = 0, error_count = 0; + double *my_jitter_array; + ACE_NEW_RETURN (my_jitter_array, double [ts_->loop_count_], 1); + + double latency = 0; + double sleep_time = (1/frequency) * (1000 * 1000); + double delta = 0; + + int pstartTime = 0; + int pstopTime = 0; + double real_time = 0.0; + +#if defined (USE_QUANTIFY) + quantify_stop_recording_data(); + quantify_clear_data (); +#endif /* USE_QUANTIFY */ + + // Make the calls in a loop. + for (i = 0; i < loop_count; i++) + { + ACE_High_Res_Timer timer_; + ACE_Time_Value tv (0, (long int) (sleep_time - delta)); + ACE_OS::sleep (tv); + + // Elapsed time will be in microseconds. + ACE_Time_Value delta_t; + +#if defined (CHORUS) + pstartTime = pccTime1Get(); +#else /* CHORUS */ + timer_.start (); +#endif /* !CHORUS */ + + switch (datatype) + { + case CB_OCTET: + { + // Cube an octet. + CORBA::Octet arg_octet = func (i), ret_octet = 0; + +#if defined (USE_QUANTIFY) + /* start recording quantify data from here */ + quantify_start_recording_data (); +#endif /* USE_QUANTIFY */ + ret_octet = cb->cube_octet (arg_octet, env); + +#if defined (USE_QUANTIFY) + quantify_stop_recording_data(); +#endif /* USE_QUANTIFY */ + + if (env.exception () != 0) + { + CORBA::SystemException* ex; + + ex = CORBA::SystemException::_narrow(env.exception()); + if (ex) + { + CORBA::String_var msg = ex->message(); + fprintf(stderr, "%s.\n", (const char*) msg); + } + else + { + fprintf(stderr, "Unknown user exception.\n"); + } + ACE_ERROR_RETURN ((LM_ERROR,"%s:Call failed\n", env.exception ()), 2); + } + + arg_octet = arg_octet * arg_octet * arg_octet; + + if (arg_octet != ret_octet) + { + ACE_DEBUG ((LM_DEBUG, "** cube_octet(%d) (--> %d)\n", arg_octet , ret_octet)); + error_count++; + } + call_count++; + } + break; + + case CB_SHORT: + // Cube a short. + { + call_count++; + + CORBA::Short arg_short = func (i), ret_short; + +#if defined (USE_QUANTIFY) + // start recording quantify data from here. + quantify_start_recording_data (); +#endif /* USE_QUANTIFY */ + + ret_short = cb->cube_short (arg_short, env); + +#if defined (USE_QUANTIFY) + quantify_stop_recording_data(); +#endif /* USE_QUANTIFY */ + + if (env.exception () != 0) + ACE_ERROR_RETURN ((LM_ERROR, + "%s:Call failed\n", + env.exception ()), + 2); + + arg_short = arg_short * arg_short * arg_short; + + if (arg_short != ret_short) + { + ACE_DEBUG ((LM_DEBUG, "** cube_short(%d) (--> %d)\n", arg_short , ret_short)); + error_count++; + } + break; + } + // Cube a long. + + case CB_LONG: + { + call_count++; + + CORBA::Long arg_long = func (i), ret_long; + +#if defined (USE_QUANTIFY) + // start recording quantify data from here. + quantify_start_recording_data (); +#endif /* USE_QUANTIFY */ + + ret_long = cb->cube_long (arg_long, env); + +#if defined (USE_QUANTIFY) + quantify_stop_recording_data(); +#endif /* USE_QUANTIFY */ + + if (env.exception () != 0) + ACE_ERROR_RETURN ((LM_ERROR,"%s:Call failed\n", env.exception ()), 2); + + arg_long = arg_long * arg_long * arg_long; + + if (arg_long != ret_long) + { + ACE_DEBUG ((LM_DEBUG, "** cube_long(%d) (--> %d)\n", arg_long , ret_long)); + error_count++; + } + break; + } + + case CB_STRUCT: + // Cube a "struct" ... + { + Cubit::Many arg_struct, ret_struct; + + call_count++; + + arg_struct.l = func (i); + arg_struct.s = func (i); + arg_struct.o = func (i); + +#if defined (USE_QUANTIFY) + // start recording quantify data from here. + quantify_start_recording_data (); +#endif /* USE_QUANTIFY */ + + ret_struct = cb->cube_struct (arg_struct, env); + +#if defined (USE_QUANTIFY) + quantify_stop_recording_data(); +#endif /* USE_QUANTIFY */ + + if (env.exception () != 0) + ACE_ERROR_RETURN ((LM_ERROR,"%s:Call failed\n", env.exception ()), 2); + + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l ; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s ; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o ; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o ) + { + ACE_DEBUG ((LM_DEBUG, "**cube_struct error!\n")); + error_count++; + } + + break; + } + } + + // use sysBench when CHORUS defined and option specified on command line +#if defined (CHORUS) + if ( (loop_count % ts_->grain_) == 0) + pstopTime = pccTime1Get(); +#else /* CHORUS */ + // if CHORUS is not defined just use plain timer_.stop (). + timer_.stop (); + timer_.elapsed_time (delta_t); +#endif /* !CHORUS */ + + // Calculate time elapsed +#if defined (ACE_LACKS_FLOATING_POINT) +# if defined (CHORUS) + real_time = pstopTime - pstartTime; + my_jitter_array [i/ts_->grain_] = real_time; // in units of microseconds. + // update the latency array, correcting the index using the granularity +# else /* CHORUS */ + // Store the time in usecs. + real_time = delta_t.sec () * ACE_ONE_SECOND_IN_USECS + + delta_t.usec (); + my_jitter_array [i] = real_time; // in units of microseconds. +# endif /* !CHORUS */ + delta = ((40 * fabs (real_time) / 100) + (60 * delta / 100)); // pow(10,6) + latency += real_time; +#else /* ACE_LACKS_FLOATING_POINT */ + // Store the time in secs. + real_time = delta_t.sec () + (double)delta_t.usec () / ACE_ONE_SECOND_IN_USECS; + delta = ((0.4 * fabs (real_time * (1000 * 1000))) + (0.6 * delta)); // pow(10,6) + latency += real_time; + my_jitter_array [i] = real_time * 1000; +#endif /* !ACE_LACKS_FLOATING_POINT */ + } + + if (call_count > 0) + { + if (error_count == 0) + { +#if defined (ACE_LACKS_FLOATING_POINT) + double calls_per_second = (call_count * ACE_ONE_SECOND_IN_USECS) / latency; +#endif /* ACE_LACKS_FLOATING_POINT */ + + latency /= call_count; + + if (latency > 0) + { +#if defined (ACE_LACKS_FLOATING_POINT) + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) cube average call ACE_OS::time\t= %u usec, \t" + "%u calls/second\n", + latency, + calls_per_second)); + + this->put_latency (my_jitter_array, + latency, + thread_id); +#else + ACE_DEBUG ((LM_DEBUG, "(%P|%t) cube average call ACE_OS::time\t= %f msec, \t" + "%f calls/second\n", + latency * 1000, + 1 / latency)); + this->put_latency (my_jitter_array, + latency * 1000, + thread_id); +#endif /* ! ACE_LACKS_FLOATING_POINT */ + } + else + { + // still we have to call this function to store a valid array pointer. + this->put_latency (my_jitter_array, + 0, + thread_id); + ACE_DEBUG ((LM_DEBUG, + "*** Warning: Latency is less than or equal to zero." + " Precision may have been lost.\n")); + } + } + ACE_DEBUG ((LM_DEBUG, + "%d calls, %d errors\n", + call_count, + error_count)); + } + + // cb->please_exit (env); + return 0; +} diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/Task_Client.h b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Task_Client.h new file mode 100644 index 00000000000..5b04c3a73b5 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Task_Client.h @@ -0,0 +1,191 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests +// +// = FILENAME +// Task_Client.h +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee and Sergio Flores-Gaitan +// +// ============================================================================ + +#if !defined (TASK_CLIENT_H) +#define TASK_CLIENT_H + +#include <corba/cool.H> +#include "api/api.H" +#include "cubit.H" + +#include "ace/Synch.h" +#include "ace/Task.h" +#include "ace/Thread_Manager.h" +#include "ace/Get_Opt.h" +#include "ace/Profile_Timer.h" +#include <math.h> + +#if defined (CHORUS) +#include "pccTimer.h" +#endif /* CHORUS */ + +// @@ Should we put this into a more general file, e.g., OS.h? +// +// I will integrate this, together with the sqrt() function when +// the implementation is complete. --Sergio. +// @@ Sergio, can you please use the ACE_timer_t here rather than #define'ing double? +#if defined (ACE_LACKS_FLOATING_POINT) +#define double ACE_UINT32 +#define fabs(X) ((X) >= 0 ? (X) : -(X)) +// the following is just temporary, until we finish the sqrt() +// implementation. +#define sqrt(X) (1) +#endif /* ACE_LACKS_FLOATING_POINT */ + +// Arbitrary generator used by the client to create the numbers to be +// cubed. +inline int +func (unsigned i) +{ + return i - 117; +} + +// The various datatypes which the client and the server can exchange. +enum Cubit_Datatypes +{ + CB_OCTET, + CB_SHORT, + CB_LONG, + CB_STRUCT +}; + +const int CB_40HZ_CONSUMER = 0; +const int CB_20HZ_CONSUMER = 1; +const int CB_10HZ_CONSUMER = 2; +const int CB_5HZ_CONSUMER = 3; +const int CB_1HZ_CONSUMER = 4; + +const int CB_40HZ_CONSUMER_RATE = 40; +const int CB_20HZ_CONSUMER_RATE = 20; +const int CB_10HZ_CONSUMER_RATE = 10; +const int CB_5HZ_CONSUMER_RATE = 5; +const int CB_1HZ_CONSUMER_RATE = 1; + +const int CB_HIGH_PRIORITY_RATE = 20; +const int CB_LOW_PRIORITY_RATE = 10; + +class Task_State + // = TITLE + // Maintains state common to multiple Cubit clients + + // = DESCRIPTION + // This class maintains state which is common to the potentially + // multiple concurrent clients. +{ +public: + ACE_Barrier *barrier_; + // Barrier for the multiple clients to synchronize after + // binding to the servants. + + Task_State (int argc, char **argv); + // Constructor. Takes the command line arguments, which are + // later passed into ORB_init + + u_int start_count_; + // keeps a count of the number of clients started.. This + // count also serves as a thread-id. The first thread created + // gets an ID of 0, then 1, and so on.. + + u_int loop_count_; + // number of times to loop, making calls.. + + u_int thread_count_; + // number of concurrent clients to create.. + + u_int base_port_; + // this is the port at which the high priority servant is + // listening.. lower priority ports begin at base_port_ + 1 + + char server_host_ [1024]; + // Server hostname + + double *latency_; + // Array to store the latency for every client, indexed by + // thread-id. + + Cubit_Datatypes datatype_; + // Which datatype to use to make the calls + + ACE_Thread_Mutex lock_; + // lock to protect access to this object + + int argc_; + char **argv_; + // command line arguments + + u_int thread_per_rate_; + // Flag for the thread_per_rate test + + double **global_jitter_array_; + // this array stores the latency seen by each client for each + // request, to be used later to compute jitter + + u_int use_chorus_ipc_; + // flag that indicates that we are going to use Chorus IPC + // communication mechanism, instead of the TCP/IP protocol stack. + // This only applies to the CHORUS ClassiX OS. + + char * ior_header_; + // pointer to the ior part where you specify the type of transport + // for COOL (i.e. ipc or tcp) + + u_int grain_; + // this is the granularity of the timing of the CORBA requests. A + // value of 5 represents that we will take time every 5 requests, + // instead of the default of every request (1). +}; + +class Client : public ACE_Task<ACE_MT_SYNCH> + // = TITLE + // The Cubit client. +{ +public: + Client (Task_State *ts); + // constructor, with a pointer to the common task state. + + virtual int svc (void); + // the thread function + + double get_high_priority_latency (void); + double get_low_priority_latency (void); + double get_high_priority_jitter (void); + double get_low_priority_jitter (void); + int get_latency (u_int thread_id); + // accessors to get the various measured quantities + + +private: + + int run_tests (Cubit_ptr, + unsigned int, + unsigned int, + Cubit_Datatypes, + double frequency); + // makes the calls to the servant + + void put_latency (double *jitter, + double latency, + unsigned int); + // Records the latencies in the Task_State + + int parse_args (int, char **); + // parses the arguments + + Task_State *ts_; + // pointer to shared state + +}; + +#endif /* !defined (TASK_CLIENT_H) */ diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/Util_Thread.cpp b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Util_Thread.cpp new file mode 100644 index 00000000000..5a63a86339c --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Util_Thread.cpp @@ -0,0 +1,62 @@ +// $Id$ + +#include "Util_Thread.h" + +ACE_RCSID(MT_Cubit, Util_Thread, "$Id$") + +Util_Thread::Util_Thread (Task_State *ts, + ACE_Thread_Manager *thr_mgr) + : ACE_Task<ACE_MT_SYNCH> (thr_mgr), + done_ (0), + number_of_computations_ (0), + ts_ (ts) +{ +} + +int +Util_Thread::svc (void) +{ + ACE_DEBUG ((LM_DEBUG, + "(%t) Utilization Thread created, " + "waiting for threads to finish binding\n")); + + // this barrier synchronizes the utilization thread with + // the client threads + // i.e., the Util_thread should wait until all the + // clients have finished binding, and only then + // start measuring the utilization. + this->ts_->barrier_->wait (); + + ACE_DEBUG ((LM_DEBUG, + "(%t) Threads have bound, " + "utilization test started\n")); + + this->run_computations (); + return 0; +} + +double +Util_Thread::get_number_of_computations (void) +{ + return this->number_of_computations_; +} + +// Perform repeated prime factor computations on an arbitrary number. +// And you thought your life was boring... :-) + +int +Util_Thread::run_computations (void) +{ + while (this->done_ == 0) + { + // See if this number is prime. 2 and CUBIT_ARBIT_NUMBER / 2 are + // the recommended values for min_factor and max_factor, as + // explained in ACE.h (is_prime). + ACE::is_prime (CUBIT_ARBIT_NUMBER, + 2, + CUBIT_ARBIT_NUMBER / 2); + this->number_of_computations_ ++; + } + + return 0; +} diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/Util_Thread.h b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Util_Thread.h new file mode 100644 index 00000000000..b336c11c2de --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/Util_Thread.h @@ -0,0 +1,45 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests +// +// = FILENAME +// Util_Thread.h +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "Task_Client.h" + +const int CUBIT_ARBIT_NUMBER = 2064885; + +class Util_Thread : public ACE_Task<ACE_MT_SYNCH> + // = TITLE + // The thread that computes utilization. +{ +public: + Util_Thread (Task_State *, + ACE_Thread_Manager *thr_mgr); + // constructor. + + virtual int svc (void); + // The thread entry point function. + + double get_number_of_computations (void); + // Gets the number of computations the thread was able to perform. + + int done_; + // Indicates whether we're done. + +private: + int run_computations (void); + // Run the computations. + + // Sumedh, please add comments here. + double number_of_computations_; + Task_State *ts_; +}; diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/client.cpp b/TAO/performance-tests/Cubit/COOL/MT_Cubit/client.cpp new file mode 100644 index 00000000000..0a1dbcc474c --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/client.cpp @@ -0,0 +1,289 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests +// +// = FILENAME +// client.cpp +// +// = AUTHOR +// Andy Gokhale, Brian Mendel, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "client.h" + +ACE_RCSID(MT_Cubit, client, "$Id$") + +int +initialize (void) +{ +#if defined (VXWORKS) + hostAdd ("mv2604d", "130.38.183.132"); +#if defined (VME_DRIVER) + STATUS status = vmeDrv (); + if (status != OK) + printf ("ERROR on call to vmeDrv()\n"); + status = vmeDevCreate ("/vme"); + if (status != OK) + printf ("ERROR on call to vmeDevCreate()\n"); +#endif /* defined (VME_DRIVER) */ +#endif /* defined (VXWORKS) */ + + // Make sure we've got plenty of socket handles. This call will use + // the default maximum. + ACE::set_handle_limit (); + return 0; +} + +int +do_priority_inversion_test (Task_State &ts) +{ + u_int i = 0; + + // Create the clients + Client high_priority_client (&ts); + Client low_priority_client (&ts); + + // Create the daemon thread in its own <ACE_Thread_Manager>. + ACE_Thread_Manager thr_mgr; + + Util_Thread util_thread (&ts, &thr_mgr); + + ACE_Sched_Priority priority = + ACE_Sched_Params::priority_min (ACE_SCHED_FIFO, + ACE_SCOPE_THREAD); + + // First activate the Utilization thread. It will wait until all + // threads have finished binding. + util_thread.activate (THR_BOUND, + 1, + 0, + priority); + + // Now activate the high priority client. + priority = ACE_THR_PRI_FIFO_DEF; + + if (high_priority_client.activate (THR_BOUND | ACE_SCHED_FIFO, + 1, + 0, + priority) == -1) + ACE_ERROR ((LM_ERROR, + "%p\n", + "activate failed")); + + // Drop the priority, so that the priority of clients will increase + // with increasing client number. + for (i = 0; i < ts.thread_count_; i++) + priority = ACE_Sched_Params::previous_priority (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_THREAD); + + ACE_DEBUG ((LM_DEBUG, + "Creating %d clients with low priority of %d\n", + ts.thread_count_ - 1, + priority)); + + for (i = 0; i < ts.thread_count_ - 1; i++) + { + // The first thread starts at min + 1, since the minimum + // priority thread is the utilization thread. + + if (low_priority_client.activate (THR_BOUND, + 1, + 1, + priority) == -1) + ACE_ERROR ((LM_ERROR, + "%p\n", + "activate failed")); + + // get the next higher priority + priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO, + priority, + ACE_SCOPE_THREAD); + } + // Wait for all the threads to exit. + ACE_Thread_Manager::instance ()->wait (); + +#if defined (VXWORKS) + ACE_OS::printf ("Test done.\n" + "High priority client latency : %d usec\n" + "Low priority client latency : %d usec\n", + high_client.get_high_priority_latency (), + low_client.get_low_priority_latency ()); +#elif defined (CHORUS) + ACE_OS::printf ("Test done.\n" + "High priority client latency : %u usec\n" + "Low priority client latency : %u usec\n", + high_priority_client.get_high_priority_latency (), + low_priority_client.get_low_priority_latency ()); + + // output the latency values to a file, tab separated, to import it + // to Excel to calculate jitter, in the mean time we come up with + // the sqrt() function. + FILE *latency_file_handle = 0; + char latency_file[BUFSIZ]; + char buffer[BUFSIZ]; + + ACE_OS::sprintf (latency_file, + "cb__%d.txt", + ts.thread_count_); + + ACE_OS::fprintf(stderr, + "--->Output file for latency data is \"%s\"\n", + latency_file); + + latency_file_handle = ACE_OS::fopen (latency_file, "w"); + + for (u_int j = 0; j < ts.start_count_; j ++) + { + ACE_OS::sprintf(buffer, + "%s #%d", + j==0? "High Priority": "Low Priority", + j); + for (u_int i = 0; i < ts.loop_count_; i ++) + { + ACE_OS::sprintf(buffer+strlen(buffer), + "\t%u\n", + ts.global_jitter_array_[j][i]); + fputs (buffer, latency_file_handle); + buffer[0]=0; + } + } + + ACE_OS::fclose (latency_file_handle); +#else + ACE_DEBUG ((LM_DEBUG, "Test done.\n" + "High priority client latency : %f msec, jitter: %f msec\n" + "Low priority client latency : %f msec, jitter: %f msec\n", + high_priority_client.get_high_priority_latency (), + high_priority_client.get_high_priority_jitter (), + low_priority_client.get_low_priority_latency (), + low_priority_client.get_low_priority_jitter ())); +#endif /* !defined (CHORUS) && !defined (VXWORKS) */ + + // signal the utilization thread to finish with its work.. + util_thread.done_ = 1; + + // This will wait for the utilization thread to finish. + thr_mgr.wait (); + +#if defined (ACE_LACKS_FLOATING_POINT) + ACE_DEBUG ((LM_DEBUG, + "(%t) utilization task performed %u computations\n", + util_thread.get_number_of_computations ())); +#else + ACE_DEBUG ((LM_DEBUG, + "(%t) utilization task performed %g computations\n", + util_thread.get_number_of_computations ())); +#endif /* ! ACE_LACKS_FLOATING_POINT */ + + return 0; + +} + +int +do_thread_per_rate_test (Task_State &ts) +{ + // First activate the high priority client. + Client CB_40Hz_client (&ts); + Client CB_20Hz_client (&ts); + Client CB_10Hz_client (&ts); + Client CB_5Hz_client (&ts); + Client CB_1Hz_client (&ts); + + ACE_Sched_Priority priority = + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO, + ACE_SCOPE_THREAD); + + // VxWorks priority of 0 causes problems. + priority = 10; + ACE_DEBUG ((LM_DEBUG, "Creating 40 Hz client with priority %d\n", priority)); + if (CB_40Hz_client.activate (THR_BOUND, 1, 0, priority++) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed")); + + ACE_DEBUG ((LM_DEBUG, "Creating 20 Hz client with priority %d\n", priority)); + if (CB_20Hz_client.activate (THR_BOUND, 1, 0, priority++) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed")); + + ACE_DEBUG ((LM_DEBUG, "Creating 10 Hz client with priority %d\n", priority)); + if (CB_10Hz_client.activate (THR_BOUND, 1, 0, priority++) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed")); + + ACE_DEBUG ((LM_DEBUG, "Creating 5 Hz client with priority %d\n", priority)); + if (CB_5Hz_client.activate (THR_BOUND, 1, 0, priority++) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed")); + + ACE_DEBUG ((LM_DEBUG, "Creating 1 Hz client with priority %d\n", priority)); + if (CB_1Hz_client.activate (THR_BOUND, 1, 0, priority++) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed")); + + // Wait for all the threads to exit. + ACE_Thread_Manager::instance ()->wait (); + + ACE_OS::printf ("Test done.\n" + "40Hz client latency : %d usec\n" + "20Hz client latency : %d usec\n" + "10Hz client latency : %d usec\n" + "5Hz client latency : %d usec\n" + "1Hz client latency : %d usec\n", + CB_40Hz_client.get_latency (0), + CB_20Hz_client.get_latency (1), + CB_10Hz_client.get_latency (2), + CB_5Hz_client.get_latency (3), + CB_1Hz_client.get_latency (4)); + return 0; +} + +// This is the main routine of the client, where we create a high +// priority and a low priority client. we then activate the clients +// with the appropriate priority threads, and wait for them to +// finish. After they aer done, we compute the latency and jitter +// metrics and print them. + +int +main (int argc, char *argv []) +{ +#if defined (FORCE_ARGS) + int argc = 7; + char *argv[] = {"main", + "-d", + "3", // Data Type + "-t", + "10", // Thread Count + "-h", + "mv2604d"}; // Host name +#endif /* defined (FORCE_ARGS) */ + + Task_State ts (argc, argv); + +#if defined (CHORUS) + // start the pccTimer for chorus classix + int pTime; + + // Initialize the PCC timer Chip + pccTimerInit(); + + if(pccTimer(PCC2_TIMER1_START,&pTime) !=K_OK) + { + printf("pccTimer has a pending bench mark\n"); + } +#endif + + if (ts.thread_per_rate_ == 0) + do_priority_inversion_test (ts); + else + do_thread_per_rate_test (ts); + +#if defined (CHORUS) + // stop the pccTimer for chorus ClassiX + if(pccTimer(PCC2_TIMER1_STOP,&pTime) !=K_OK) + { + printf("pccTimer has a pending benchmark\n"); + } +#endif + + return 0; +} diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/client.h b/TAO/performance-tests/Cubit/COOL/MT_Cubit/client.h new file mode 100644 index 00000000000..b4066444a7c --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/client.h @@ -0,0 +1,36 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests +// +// = FILENAME +// client.h +// +// = AUTHOR +// Andy Gokhale, Brian Mendel, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#include <corba/cool.H> +#include "cubit.H" + +#include "ace/Task.h" +#include "ace/Thread_Manager.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" + +#include "Task_Client.h" +#include "Util_Thread.h" + +#if defined (CHORUS) +#include "pccTimer.h" +#endif /* CHORUS */ + +#if defined (VME_DRIVER) +#include <hostLib.h> +extern "C" STATUS vmeDrv (void); +extern "C" STATUS vmeDevCreate (char *); +#endif /* defined (VME_DRIVER) */ + diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit.idl b/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit.idl new file mode 100644 index 00000000000..d4f1610e2a8 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit.idl @@ -0,0 +1,42 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. + +#pragma prefix "Eng.SUN.COM" +#pragma version Cubit 1.1 + +interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); +}; diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit_i.cpp b/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit_i.cpp new file mode 100644 index 00000000000..baf630d7dc5 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit_i.cpp @@ -0,0 +1,69 @@ +// $Id$ + +#include "cubit_impl.h" +#include "ace/ACE.h" + +ACE_RCSID(MT_Cubit, cubit_impl, "$Id$") + +Cubit_Impl::Cubit_Impl (Task_State *ts) + :ts_ (ts), + util_started_ (0) +{ +} + +CORBA::Octet Cubit_Impl:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) +{ + // ACE_DEBUG ((LM_DEBUG, "octet cubed is %d\n", o*o*o)); + if (ts_->run_server_utilization_test_ == 1 && + ts_->utilization_task_started_ == 0 && + this->util_started_ == 0 ) + { + this->util_started_ = 1; + ts_->barrier_->wait (); + } + + ts_->loop_count_++; + + return (CORBA::Octet) (o * o * o); +} + +CORBA::Short Cubit_Impl:: cube_short (CORBA::Short s, CORBA::Environment &IT_env) { + return (CORBA::Short) (s * s * s); +} + +CORBA::Long Cubit_Impl:: cube_long (CORBA::Long l, CORBA::Environment &IT_env) { + return (CORBA::Long) (l * l * l); +} + +Cubit::Many Cubit_Impl:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) { + Cubit::Many out_values; + out_values.o = values.o * values.o * values.o; + out_values.s = values.s * values.s * values.s; + out_values.l = values.l * values.l * values.l; + return out_values; +} + +Cubit::oneof Cubit_Impl:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) { + Cubit::oneof out_values; + switch (values._d ()) { + case Cubit::e_0th: + out_values.o (values.o () * values.o () * values.o ()); + break; + case Cubit::e_1st: + out_values.s (values.s () * values.s () * values.s ()); + break; + case Cubit::e_2nd: + out_values.l (values.l () * values.l () * values.l ()); + break; + case Cubit::e_3rd: + default: + out_values.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o ; + out_values.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s ; + out_values.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l ; + break; + } + return out_values; +} + +void Cubit_Impl:: please_exit (CORBA::Environment &IT_env) { +} diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit_i.h b/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit_i.h new file mode 100644 index 00000000000..77eecdbbd10 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/cubit_i.h @@ -0,0 +1,27 @@ +// $Id$ + +#ifndef cubit_ih +#define cubit_ih + +#include <corba/cool.H> +#include "cubit.H" +#include "Task_Client.h" + +class Cubit_Impl { +public: + Cubit_Impl (Task_State *ts); + virtual CORBA_Octet cube_octet (CORBA_Octet o, CORBA_Environment &IT_env=_environment); + virtual CORBA_Short cube_short (CORBA_Short s, CORBA_Environment &IT_env=_environment); + virtual CORBA_Long cube_long (CORBA_Long l, CORBA_Environment &IT_env=_environment); + virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA_Environment &IT_env=_environment); + virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA_Environment &IT_env=_environment); + virtual void please_exit (CORBA_Environment &IT_env=_environment); + +private: + Task_State *ts_; + //pointer to the task state + int util_started_; + // flag to indicate utilization test has started +}; + +#endif diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/pccTimer.cpp b/TAO/performance-tests/Cubit/COOL/MT_Cubit/pccTimer.cpp new file mode 100644 index 00000000000..a8846b631f9 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/pccTimer.cpp @@ -0,0 +1,281 @@ +// $Id$ + +/* + **************************************************************** + * + * Component = pccTimer.C - mvme167 + * + * Synopsis = + * + * Copyright (c) 1995, 1996, 1997 Chorus systemes + * (R) Chorus is a registered trademark of Chorus systemes + * + **************************************************************** + * + * + **************************************************************** + */ + +/* Everything is relative from +/vobs/chorus_work/merge1/mvme177/appl/include/chorus +*/ + +#include <stdio.h> +#include <chorus.h> +#include <exec/chContext.h> +//#include <exec/c_cpuContext.H> +#include <util/chKnTimeVal.h> +//#include <util/macro.h> +#include <tick/chTick.h> +//#include <kbim/p_chIntr.h> +//#include <stdconsio.h> +#include <bsp/pccchip2.h> +#include <bsp/nvram.h> +#include <bsp/board.h> +#include <exec/chPanic.h> +#include <bsp/intrLevel.h> +#include <timer/chProf.h> +#include <exec/f_chTrap.h> +#include <ims/ims_f.h> +//#include <sched/schedIntf.H> +//#include <p_boardInfo.H> +#include "pccTimer.h" + +ACE_RCSID(MT_Cubit, pccTimer, "$Id$") + + +static unsigned int quartz; +static unsigned int timer_reload_value; +int timerHz = 100; + +volatile struct +pccchip2 *pccchip2 = (volatile struct pccchip2 *) PCCchip2_BASE; + +volatile struct +nvram* nvram = ((volatile struct nvram*)NVRAM_BASE); + + +int +pccTimer(int option, int* uTime) +{ + KnTimeVal time; + + int res = K_EOK; + //option &= ~PCC_USERDATA; + static int benchEnable1 = 0; + static int benchEnable2 = 0; + static unsigned int benchLastTime = 0; + + switch(option) + { + + case PCC2_TIMER1_START: + if (benchEnable1) return K_EINVAL; + benchEnable1 = 1; + pccTimer1Start(); + benchLastTime = pccTimer1Reset(); + break; + + case PCC2_TIMER1_STOP: + benchLastTime = pccTime1Get(); + if (!benchEnable1) return K_EINVAL; + benchEnable1 = 0; + pccTimer1Stop(); + break; + + case PCC2_TIMER1_BPOINT: + benchLastTime = pccTime1Get(); + if (!benchEnable1) return K_EINVAL; + break; + + case PCC2_TIMER2_START: + if (benchEnable2) return K_EINVAL; + benchEnable2 = 1; + pccTimer2Start(); + benchLastTime = pccTimer2Reset(); + break; + + case PCC2_TIMER2_STOP: + benchLastTime = pccTime2Get(); + if (!benchEnable2) return K_EINVAL; + benchEnable2 = 0; + pccTimer2Stop(); + break; + + case PCC2_TIMER2_BPOINT: + benchLastTime = pccTime2Get(); + if (!benchEnable2) return K_EINVAL; + break; + + default: + return K_EINVAL; + } + + // Here only is last time must be returned + if (uTime) + { + *uTime = benchLastTime; + } + + return res; +} + + + // + // Return the value of the timer counter, in microseconds. + // + unsigned int +pccTime1Get() +{ + return pccchip2->timer1cnt; +} + + unsigned int +pccTimer1Reset() +{ + pccchip2->timer1cnt = 0; + return pccchip2->timer1cnt; +} + + void +pccTimer1Start() +{ + unsigned int temp; + + // Clear the counter + pccchip2->timer1cnt = 0; + // Start the counter running + // Do not reset the counter when it matches the compare register (~PCC2_COC) + // Clear the overflow counter + temp = pccchip2->timer1ctl; + pccchip2->timer1ctl = temp | PCC2_COVF | ~PCC2_COC | PCC2_CEN; + +} + + void +pccTimer1Stop() +{ + unsigned int temp; + + // Stop the counter running + temp = pccchip2->timer1ctl; + pccchip2->timer1ctl = temp | ~PCC2_CEN; + +} + + + // + // Return the value of the timer counter, in microseconds. + // + unsigned int +pccTime2Get() +{ + return pccchip2->timer2cnt; +} + + unsigned int +pccTimer2Reset() +{ + pccchip2->timer2cnt = 0; + return pccchip2->timer2cnt; +} + + void +pccTimer2Start() +{ + unsigned int temp; + + // Clear the counter + pccchip2->timer2cnt = 0; + // Start the counter running + // Do not reset the counter when it matches the compare register (~PCC2_COC) + // Clear the overflow counter + temp = pccchip2->timer2ctl; + pccchip2->timer2ctl = temp | PCC2_COVF | ~PCC2_COC | PCC2_CEN; + +} + + void +pccTimer2Stop() +{ + unsigned int temp; + + // Stop the counter running + temp = pccchip2->timer2ctl; + pccchip2->timer2ctl = temp | ~PCC2_CEN; + +} + + // + // Init the PCC2 timer + // + void +pccTimerInit() +{ + volatile unsigned int temp; + char c; + + /* compute board quartz frequency from nvram information */ + c = nvram->config_rom.speed[0]; + quartz = ((unsigned int) c - (unsigned int) '0') * 10; + c = nvram->config_rom.speed[1]; + quartz += ((unsigned int) c - (unsigned int) '0'); + + /* Step 1. Initialize prescaler control register */ + /* On a mvme177, the VME2Chip runs at half the MPU speed */ + temp = pccchip2->prescaleadjust & 0xFFFFFF00; + + switch(quartz) { + case 60 : pccchip2->prescaleadjust = temp | 0x000000E2; /* 256-30 */ + // ASSERT(((BoardInfo*)chorusContext->ctxBoardInfo)->boardId + // == BOARD_MVME177); + break; + default : { + char tab [80]; + printf(tab,"%s : %d", "Unknown clock frequency", quartz); + svSysPanic(KP_DEBUG, 0, 0, tab, __FILE__, __LINE__); + } + } + + timer_reload_value = 1000000 / timerHz; + + + /* Step 2. Set pcc timer 1 and timer 2 compare register */ +// pccchip2->timer1cmp = timer_reload_value; + pccchip2->timer1cmp = ~0; + pccchip2->timer2cmp = ~0; + + + /* Step 3. Clear timer 1 and timer 2 counter register */ + pccchip2->timer1cnt = 0; + pccchip2->timer2cnt = 0; + + + /* Step 4. Enable pcc timer 1 and timer 2*/ + temp = pccchip2->timer1ctl; + pccchip2->timer1ctl = temp | PCC2_COVF | PCC2_COC | PCC2_CEN; + + temp = pccchip2->timer2ctl; + pccchip2->timer2ctl = temp | PCC2_COVF | PCC2_COC | PCC2_CEN; + + + /* Step 5. VBR is already set */ +// No need to change the VBR if we are not Compare Feature of the PCC2 Timer + + /* Step 6. set the pcc timer 1 interrupt level */ +// temp = pccchip2->irqlvl1; +// temp = temp & 0xfffffff8; +// pccchip2->irqlvl1 = temp | TIMER_INT_LEVEL; + + + // KnIntrEntry clockConf; + + //clockConf.name = VME_CHIP2_TIMER1; + //clockConf.hdl = getHdlFromCf(); + //clockConf.on = clockStart_p; + //clockConf.off = clockStop_p; + //clockConf.down = clockDown_p; + //clockConf.ison = clockTest_p; + + //svIntrConnect (&clockConf); +} diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/pccTimer.h b/TAO/performance-tests/Cubit/COOL/MT_Cubit/pccTimer.h new file mode 100644 index 00000000000..453977e6661 --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/pccTimer.h @@ -0,0 +1,56 @@ +// $Id$ +/* + **************************************************************** + * + * Component = PCC2 Timer Header File + * + * Synopsis = + * + * + **************************************************************** + * + * + **************************************************************** + */ + + + +#ifndef _PCCTIMER_H +#define _PCCTIMER_H + +int +pccTimer(int option, int* uTime); +unsigned int +pccTime1Get(); +unsigned int +pccTimer1Reset(); +void +pccTimer1Start(); +void +pccTimer1Stop(); +unsigned int +pccTime2Get(); +unsigned int +pccTimer2Reset(); +void +pccTimer2Start(); +void +pccTimer2Stop(); +void +pccTimerInit(); + + +#define PCC2_TIMER1_START 0x0 +#define PCC2_TIMER1_STOP 0x1 +#define PCC2_TIMER1_BPOINT 0x2 +#define PCC2_TIMER2_START 0x10 +#define PCC2_TIMER2_STOP 0x20 +#define PCC2_TIMER2_BPOINT 0x40 +#define PCC2_USERDATA 0x100 + +#include <c_defs.h> +#include <mem/chAddr_f.h> + +//extern_C int sysBench __((int, int*)); + +#endif /* _PCCTIMER_H */ diff --git a/TAO/performance-tests/Cubit/COOL/MT_Cubit/server.cpp b/TAO/performance-tests/Cubit/COOL/MT_Cubit/server.cpp new file mode 100644 index 00000000000..e19d39e7bad --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/MT_Cubit/server.cpp @@ -0,0 +1,160 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests +// +// = FILENAME +// server.cpp +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#include <api/binding.H> +#include <api/api.H> +#include <api/coolThreadPool.H> +#include <corba/eoa.H> +#include <corba/eorb.H> + +#include "cubit.H" +#include "cubit_impl.h" // server header file +#include "sk_cubit.H" +#include "sk_cubit.C" +#include "ace/OS.h" + +ACE_RCSID(MT_Cubit, server, "$Id$") + +CORBA_BOA_ptr boa; + +int +create_servant (void *arg) +{ + char ** argv = (char **) arg; + + CORBA_Environment env; + Cubit_ptr cubit; + Cubit_Impl cubit_impl; + + COOL_ThreadPool* MyPool_1; + u_int concurrencyModel = 0; + + if (strcmp (argv[1], "tpool") == 0) + { + // + // Defines a policy for using a pool of 20 threads. + // + concurrencyModel = THREAD_POOL; + ACE_DEBUG ((LM_DEBUG, "Using Thread Pool concurrency model\n")); + } + else if (strcmp (argv[1], "tpr") == 0) + { + // Defines policy to create a thread for each incoming + // request. + concurrencyModel = THREAD_PER_REQUEST; + ACE_DEBUG ((LM_DEBUG, "Using Thread Per Request concurrency model\n")); + } + else + { + ACE_ERROR ((LM_ERROR, "Concurrency model determination failed.\n")); + return -1; + } + + COOL_ThreadPoolControl poolCtl_1 (concurrencyModel, 1, 20, -1); + COOL_QueueControl qCtl; + + // Defines thread attributes for threads belonging to pools. + COOL_ThreadAttributes poolAttr; + struct sched_param sp; + poolAttr.init(); + poolAttr.stack_size(8192*2); + sp.sched_priority = 43; + poolAttr.sched_attr(&sp); + // + // Allocate and initialize first pool + // + MyPool_1 = new COOL_ThreadPool; + MyPool_1->init_pool(poolCtl_1, poolAttr, qCtl); + + COOL::EOABindingData bindingData (argv[2]); + bindingData.threadpool(MyPool_1); + + COOL_bind (cubit_impl, cubit, bindingData, env); + + if (env.exception ()) + { + ACE_DEBUG ((LM_ERROR, "Bind failed.\n")); + return -1; + } + + if (env.exception ()) { + ACE_DEBUG ((LM_ERROR, "Object Reference Export Failed.\n")); + return -1; + } + + ACE_DEBUG ((LM_DEBUG, "Entering boa->run ().\n")); + boa->run (); + return 0; +} + + +int +main (int argc, char** argv) +{ + CORBA_Environment env; + int i = 0; + + COOL::EOA::bind(argv[2], env); + if (env.exception()) { + ACE_DEBUG ((LM_ERROR, "Impossible to bind the ORB to the description: %s\n", argv[2])); + return -1; + } + + CORBA_ORB_ptr orb = CORBA_ORB_init (argc, argv, 0, env); + if (env.exception ()) { + ACE_DEBUG ((LM_ERROR, "ORB_init failed..\n")); + CORBA::SystemException* ex; + + ex = CORBA::SystemException::_narrow(env.exception()); + if (ex) { + CORBA::String_var msg = ex->message(); + fprintf(stderr, "%s.\n", (const char*) msg); + } else { + fprintf(stderr, "Unknown user exception.\n"); + } + return -1; + } + + boa = orb->OA_init (argc, argv, 0, env); + if (env.exception ()) + { + ACE_DEBUG ((LM_ERROR, "OA_init failed..\n")); + return -1; + } + + COOL_Activity_ptr new_activity [2]; + + for (i = 0; i < 1; i++) + { + if (thisCapsule->createActivity ((COOL_ActivityFunc) create_servant, + (void *) argv, + new_activity [i]) != C_OK) + { + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed\n")); + } + } + + CORBA_Long status; + for (i = 0; i < 1; i++) + { + if (new_activity [i]->join (status) != C_OK) + { + ACE_ERROR ((LM_ERROR, "%p\n", "join failed\n")); + } + } + + ACE_DEBUG ((LM_DEBUG, "Cubit server is exiting\n")); + return 0; +} diff --git a/TAO/performance-tests/Cubit/COOL/Makefile b/TAO/performance-tests/Cubit/COOL/Makefile new file mode 100644 index 00000000000..b0a5e0a8a8f --- /dev/null +++ b/TAO/performance-tests/Cubit/COOL/Makefile @@ -0,0 +1,22 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the COOL tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +DIRS = MT_Cubit + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nolocal.GNU + diff --git a/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/Makefile b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/Makefile new file mode 100644 index 00000000000..48238fd831b --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/Makefile @@ -0,0 +1,89 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +LDLIBS = -lcorba -lunixsvc -lpbroker -lboadc -lnaming -llifecycl -lfsstream + +IDL_SRC = cubit.cpp cubit_s.cpp +PROG_SRCS = $(IDL_SRC) svr.cpp clnt.cpp + +LSRC = $(PROG_SRCS) + +CUBIT_SVR_OBJS = cubit.o cubit_s.o svr.o cubit_i.o +CUBIT_CLT_OBJS = cubit.o clnt.o + +BIN = svr clnt +BUILD = $(BIN) +VLDLIBS = $(LDLIBS:%=%$(VAR)) +VBIN = $(BIN:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +exceptions = 1 + +#include $(PBHOME)/make/make.cfg + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +#include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#$(VDIR)%.o: %.C +#VOBJS = $(LSRC:%.C=$(VDIR)%.o) + +LDFLAGS += -L$(PBHOME)/lib +CPPFLAGS += -I$(PBHOME)/include + +$(IDL_SRC): cubit.idl + $(PBHOME)/bin/idlc cubit.idl + -/bin/mv cubit.C cubit.cpp + -/bin/mv cubit_s.C cubit_s.cpp + +svr: $(addprefix $(VDIR),$(CUBIT_SVR_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + +clnt: $(addprefix $(VDIR),$(CUBIT_CLT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + +######## +# Sanity check builds by running basic functionality tests. +# +# "sleep 5" in the server startup is usually enough to get the +# objref into the file so the client can read it. +# +check: $(TESTS) + @echo "testing with 'cube' calls, stub + DII, IOR strings" + @./svr -i30 -o non-internet > obj.1 & sleep 5 + @./clnt -n250 -O `cat obj.1` -x + @echo '' + @echo "testing request forwarding with 'cube' calls, stub + DII" + @./svr -f -i30 > obj.2 & sleep 5 + @./clnt -n250 -O `cat obj.2` -x + @echo '' + @echo "testing transmission of primitive data types" + @./test1_svr -i30 > obj.3 & sleep 5 + @./test1_clnt -n50 -O `cat obj.3` -x + @echo '' +# @echo "testing echo of primitive data values" +# @./echo_svr -i30 > obj.4 & sleep 5 +# @./echo_clnt -O `cat obj.4` -x +# @echo '' + @echo "testing with 'cube' calls, MT-ized (no forwarding)" + @./svr -t -i30 -o non-internet > obj.5 & sleep 5 + @./clnt -n250 -O `cat obj.5` -x + @echo '' + +clean: + -/bin/rm -rf *.o cubit.cpp cubit.h cubit_s.cpp cubit_s.h $(CUBIT_SVR_OBJS) $(CUBIT_CLT_OBJS) $(BIN) core + +realclean: clean + diff --git a/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/README b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/README new file mode 100644 index 00000000000..7e3219a7d4c --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/README @@ -0,0 +1,54 @@ +This is the cubit example that uses the CORBAplus IDL compiler to generate +the stubs and skeletons. Additional features include presence of a +factory to create Cubit objects. + +You can either run the server in the background in the same window as +the client or open a separate window for the client and server. + +server: +------- + +% svr [-d] [-n <number-of-cubit-objects>] [-pbtrace] + +The server cubit factory maintained num_of_cubit objects (default = +1). They are assigned keys that look like "key0", "key1", ... + +When the server is started and you have used the -d flag, you should +see a line of output that looks something like: +XpsIiopServerProfileFactory::XpsIiopServerProfileFactory() : new tcp server listening at port 45372 + +Using -d turns on debugging messages. It is additive, i.e., the more +-d options provided, the more debugging you can get. At the moment, +only 2 levels of debugging are implemented, and more than 2 -d options +are ignored. + +NOTE: + +0. $PBHOME is the directory where CORBAplus is installed. + +1. Set the appropriate environment variables for CORBAplus to work. Look at the example script at +$PBHOME/.cshrc_pb You can append this script to your .cshrc.mine file assuming you run a csh shell. +You can also execute it, like: + + source $PBHOME/.cshrc_pb + +2. Make sure the CORBAplus BOA server is running, before trying to run the server example. + + To run the BOA server execute: + + $PBHOME/bin/pbboad -pbtrace + +client: +------- + +% clnt [-d] [-k <cubit key>] [-n <iterations>] -pbinit Cubit_Factory iiop://<host>:<port>/cubit_factory + + where + <host> is the machine where the server is running. + <port> is the port number that was displayed when the server was run. See example output above. + +<cubit_key> corresponds to "key0", "key1", ... + +<iterations> are the number of times you want to execute a call. + +-d : see same option for server above.
\ No newline at end of file diff --git a/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/clnt.cpp b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/clnt.cpp new file mode 100644 index 00000000000..a6f07896f86 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/clnt.cpp @@ -0,0 +1,727 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/Cubit/CORBAplus/IDL_Cubit +// +// = FILENAME +// clnt.cpp +// +// = DESCRIPTION +// This class implements a simple "cube" CORBA client for the Cubit +// example using stubs generated by the CORBAplus ORB IDL compiler. +// +// = AUTHORS +// Andy Gokhale, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "pbroker/pberr.h" +//#include <pbroker/corba/ifr/ifrc.h> +#include "ace/Profile_Timer.h" +#include "clnt.h" + +ACE_RCSID(IDL_Cubit, clnt, "$Id$") + +int _debug_level = 1; + +// Constructor. + +Cubit_Client::Cubit_Client (void) + : cubit_factory_key_ ("cubit_factory"), + cubit_key_ ("key0"), + hostname_ (ACE_DEFAULT_SERVER_HOST), + portnum_ (ACE_DEFAULT_SERVER_PORT), + loop_count_ (250), + exit_later_ (0), + factory_ (Cubit_Factory::_nil ()), + objref_ (CORBA::Object::_nil ()), + cubit_ (Cubit::_nil ()), + orb_ptr_ (0), + call_count_ (0), + error_count_ (0) +{ +} + +// Simple function that returns the substraction of 117 from the +// parameter. + +int +Cubit_Client::func (u_int i) +{ + return i - 117; +} + +// Parses the command line arguments and returns an error status. + +int +Cubit_Client::parse_args (void) +{ + ACE_Get_Opt get_opts (argc_, argv_, "dn:k:xp:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'd': // debug flag + _debug_level++; + break; + case 'n': // loop count + loop_count_ = (u_int) ACE_OS::atoi (get_opts.optarg); + break; + case 'h': + hostname_ = ACE_OS::strdup (get_opts.optarg); + break; + case 'p': + portnum_ = ACE_OS::atoi (get_opts.optarg); + break; + case 'k': // stringified objref + cubit_key_ = ACE_OS::strdup (get_opts.optarg); + break; + case 'x': + this->exit_later_++; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-d]" + " [-n loopcount]" + " [-k cubit-obj-ref-key]" + " [-x]" + " [-pbtrace]" + " -pbinit Cubit_Factory <Object_Reference>" + "\n", + this->argv_ [0]), + -1); + } + + // Indicates successful parsing of command line. + return 0; +} + +// Exercise the union. Cube a union. + +void +Cubit_Client::cube_union_stub (void) +{ + CORBA::Environment env; + Cubit::oneof u, r; + + this->call_count_++; + + u.l (3); // use the long union branch + + // Cube a "union" ... + // @@ Put exception handling here !!! + r = this->cubit_->cube_union (u); + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("from cube_union"); + this->error_count_++; + } + else + { + dmsg1 ((LM_DEBUG, "cube union ...\n")); + u.l (u.l () * u.l () * u.l ()) ; + + if (u.l () != r.l ()) + { + ACE_DEBUG ((LM_DEBUG, "** cube_union ERROR\n")); + this->error_count_++; + } + + } + + this->call_count_++; + + u._d (Cubit::e_3rd); +#if 0 + u.cm ().l = this->func (i); + u.cm ().s = this->func (i); + u.cm ().o = this->func (i); +#endif + + u.cm ().l = 7; + u.cm ().s = 5; + u.cm ().o = 3; + + // Cube another "union" which uses the default arm ... NOT tested yet + r = this->cubit_->cube_union (u); +//, this->env_); @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("from cube_union"); + this->error_count_++; + } + else + { + dmsg1 ((LM_DEBUG, "cube union ...\n")); + u.cm ().l = u.cm ().l * u.cm ().l * u.cm ().l; + u.cm ().s = u.cm ().s * u.cm ().s * u.cm ().s; + u.cm ().o = u.cm ().o * u.cm ().o * u.cm ().o; + + if (u.cm ().l != r.cm ().l + || u.cm ().s != r.cm ().s + || u.cm ().o != r.cm ().o) + { + ACE_DEBUG ((LM_DEBUG, "** cube_union ERROR\n")); + this->error_count_++; + } + } +} + +// Exercise the union using dii. + +void +Cubit_Client::cube_union_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req; + + this->call_count_++; + + req = this->cubit_->_request ((CORBA::String) "cube_union"); + //, this->env_); @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + this->error_count_++; + + // this->env_.print_exception ("cube_union_dii request create"); + return; + } + + // ... initialise the argument list and result ... + Cubit::oneof *u, r; + + u = new Cubit::oneof; + u->_d (Cubit::e_3rd); + + u->cm ().l = 5; + u->cm ().s = -7; + u->cm ().o = 3; + + CORBA::Any tmp_arg (Cubit::_tc_oneof, u, CORBA_FALSE); + + req->arguments ()->add_value ("values", tmp_arg, CORBA::ARG_IN); + //, this->env_); @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + this->error_count_++; + // this->env_.print_exception ("cube_union_dii request arg add"); + CORBA::release (req); + return; + } + + req->result ()->value ()->replace (Cubit::_tc_oneof, 0, CORBA_TRUE); + //, this->env_); @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + this->error_count_++; + // this->env_.print_exception ("cube_union_dii result type"); + CORBA::release (req); + return; + } + + // Make the invocation, verify the result. + + req->invoke (); + + if (req->env ()->exception () != 0) + { + this->error_count_++; + // req->env ()->print_exception ("cube_union_dii invoke"); + CORBA::release (req); + return; + } + + r = *(Cubit::oneof *) req->result ()->value ()->value (); + + if (r.cm ().o != 27 || r.cm ().l != 125 || r.cm ().s != -343) + { + this->error_count_++; + ACE_ERROR ((LM_ERROR, "cube_union_dii -- bad results\n")); + } + else + dmsg1 ((LM_DEBUG, "cube_union_dii ... success!!\n")); + + CORBA::release (req); + delete u; +} + +// Cube a short. + +void +Cubit_Client::cube_short (int i) +{ + CORBA::Short arg_short = this->func (i); + // Cube a short. + CORBA::Short ret_short = cubit_->cube_short (arg_short); + //, this->env_); @@ put exception handling here !! + + this->call_count_++; + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("from cube_short"); + this->error_count_++; + } + else + { + dmsg2 ((LM_DEBUG, "cube short: %d --> %d\n", + arg_short, + ret_short)); + + arg_short = arg_short * arg_short * arg_short; + + if (arg_short != ret_short) + { + ACE_ERROR ((LM_ERROR, "** cube_short (%d) ERROR (--> %d)\n", + (CORBA::Short) this->func (i), + ret_short)); + this->error_count_++; + } + } +} + +// Cube an octet + +void +Cubit_Client::cube_octet (int i) +{ + CORBA::Octet arg_octet = this->func (i); + + // Cube an octet. + CORBA::Octet ret_octet = this->cubit_->cube_octet (arg_octet); + //, this->env_); @@ put exception handling here !! + + this->call_count_++; + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("from cube_octet"); + this->error_count_++; + } + else + { + dmsg2 ((LM_DEBUG, "cube octet: %d --> %d\n", + arg_octet, + ret_octet)); + arg_octet = arg_octet * arg_octet * arg_octet; + if (arg_octet != ret_octet) { + ACE_DEBUG ((LM_DEBUG, + "** cube_octet (%d) ERROR (--> %d)\n", + (CORBA::Octet) this->func (i), + ret_octet)); + this->error_count_++; + } + } +} + +// calculate the cube from a long + +void +Cubit_Client::cube_long (int i) +{ + CORBA::Long arg_long = this->func (i); + + // Cube a long. + CORBA::Long ret_long = this->cubit_->cube_long (arg_long); + //, this->env_);; @@ put exception handling here !! + + this->call_count_++; + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("from cube_long"); + this->error_count_++; + } + else + { + dmsg2 ((LM_DEBUG, "cube long: %d --> %d\n", + arg_long, + ret_long)); + arg_long = arg_long * arg_long * arg_long; + if (arg_long != ret_long) { + ACE_ERROR ((LM_ERROR, + "** cube_long (%ld) ERROR (--> %ld)\n", + (CORBA::Long) this->func (i), + ret_long)); + this->error_count_++; + } + } +} + +// Cube the numbers in a struct + +void +Cubit_Client::cube_struct (int i) +{ + Cubit::Many arg_struct; + Cubit::Many ret_struct; + + this->call_count_++; + + arg_struct.l = this->func (i); + arg_struct.s = this->func (i); + arg_struct.o = this->func (i); + + // Cube a "struct" ... + ret_struct = this->cubit_->cube_struct (arg_struct); + //, this->env_); @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("from cube_struct"); + this->error_count_++; + } + else + { + dmsg1 ((LM_DEBUG, "cube struct ...\n")); + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o) + { + ACE_ERROR ((LM_ERROR, "** cube_struct ERROR\n")); + this->error_count_++; + } + } +} + +// Cube the numbers in a struct + +void +Cubit_Client::cube_struct_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req = + this->cubit_->_request ((CORBA::String) "cube_struct"); + //, this->env_); @@ put exception handling here !! + + this->call_count_++; + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("DII request create"); + return; + } + + // ... initialise the argument list and result ... + Cubit::Many arg; + Cubit::Many result; + + arg.o = 3; + arg.l = 5; + arg.s = -7; + + CORBA::Any tmp_arg (Cubit::_tc_Many, &arg, CORBA_FALSE); + + req->arguments ()->add_value ("values", tmp_arg, CORBA::ARG_IN); + //, this->env_); @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("DII request arg add"); + CORBA::release (req); + return; + } + + req->result ()->value ()->replace (Cubit::_tc_Many, 0, CORBA_TRUE); + //, this->env_); @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("DII request result type"); + CORBA::release (req); + return; + } + + // Make the invocation, verify the result + + req->invoke (); + + if (req->env ()->exception () != 0) + { + // req->env ()->print_exception ("DII invoke sending struct"); + CORBA::release (req); + return; + } + + result = *(Cubit::Many *) req->result ()->value ()->value (); + + if (result.o != 27 || result.l != 125 || result.s != -343) + ACE_ERROR ((LM_ERROR, "DII cube_struct -- bad results\n")); + else + dmsg1 ((LM_DEBUG, "DII cube_struct ... success!!\n")); + + CORBA::release (req); +} + +void +Cubit_Client::print_stats (const char *call_name, ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time) +{ + double tmp; + + ACE_DEBUG ((LM_DEBUG, + "%s:\n", + call_name)); + + if (this->call_count_ > 0 && this->error_count_ == 0) + { + tmp = 1000 / elapsed_time.real_time; + + elapsed_time.real_time *= ACE_ONE_SECOND_IN_MSECS; + elapsed_time.user_time *= ACE_ONE_SECOND_IN_MSECS; + elapsed_time.system_time *= ACE_ONE_SECOND_IN_MSECS; + + elapsed_time.real_time /= this->call_count_; + elapsed_time.user_time /= this->call_count_; + elapsed_time.system_time /= this->call_count_; + + tmp = 1000 / elapsed_time.real_time; + + ACE_DEBUG ((LM_DEBUG, + "\treal_time\t= %0.06f ms, \n\t" + "user_time\t= %0.06f ms, \n\t" + "system_time\t= %0.06f ms\n" + "\t%0.00f calls/second\n", + elapsed_time.real_time < 0.0? 0.0:elapsed_time.real_time, + elapsed_time.user_time < 0.0? 0.0:elapsed_time.user_time, + elapsed_time.system_time < 0.0? 0.0:elapsed_time.system_time, + tmp < 0.0? 0.0 : tmp)); + } + else + { + ACE_ERROR ((LM_ERROR, "\tNo time stats printed. Call count zero or error ocurred.\n")); + } + + ACE_DEBUG ((LM_DEBUG, + "\t%d calls, %d errors\n", + this->call_count_, + this->error_count_)); +} + +// Execute client example code. + +int +Cubit_Client::run (void) +{ + u_int i; + + ACE_Profile_Timer timer; + ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time; + + // ACE_Time_Value before; + + // We start an ACE_Profile_Timer here... + timer.start (); + + // Make the calls in a loop. + for (i = 0; i < this->loop_count_; i++) + { + this->cube_short (i); + this->cube_octet (i); + this->cube_long (i); + this->cube_struct (i); + } + + // stop the timer. + timer.stop (); + + timer.elapsed_time (elapsed_time); + // compute call average call time. + this->print_stats ("cube average call", elapsed_time); + + +#if 0 // cube_struct_dii() is not enabled for now in this test + + // Simple test for DII: call "cube_struct". (It's not timed since + // the copious mallocation of DII would bias numbers against typical + // stub-based calls). + + timer.start (); + + this->call_count_ = 0; + this->error_count_ = 0; + // Make the calls in a loop. + for (i = 0; i < this->loop_count_; i++) + { + this->cube_struct_dii (); + } + timer.stop (); + + timer.elapsed_time (elapsed_time); + // compute call average call time. + this->print_stats ("cube_struct_dii call", elapsed_time); + +#endif /* DII test not enabled for now */ + + // ------------------> + // Two more tests, using the "cube_union" function + + // unions using stubs + timer.start (); + + this->call_count_ = 0; + this->error_count_ = 0; + // Make the calls in a loop. + for (i = 0; i < this->loop_count_; i++) + { + this->cube_union_stub (); + } + + timer.stop (); + + timer.elapsed_time (elapsed_time); + // compute call average call time. + this->print_stats ("cube_union_stub call", elapsed_time); + +#if 0 // cube_union_dii() is not enabled for now in this test + // union DII + timer.start (); + + this->call_count_ = 0; + this->error_count_ = 0; + // Make the calls in a loop. + for (i = 0; i < this->loop_count_; i++) + { + this->cube_union_dii (); + } + + timer.stop (); + + timer.elapsed_time (elapsed_time); + // compute call average call time. + this->print_stats ("cube_union_dii call", elapsed_time); +#endif /* cube_union_dii test not enabled for now */ + + if (this->exit_later_) + { + this->cubit_->please_exit (); + //this->env_); @@ put exception handling here !! + //dexc (this->env_, "server, please ACE_OS::exit"); + } + + return this->error_count_ == 0 ? 0 : 1; +} + +Cubit_Client::~Cubit_Client (void) +{ + // Free resources + CORBA::release (this->orb_ptr_); + CORBA::release (this->objref_); + CORBA::release (this->factory_); + CORBA::release (this->cubit_); +} + +int +Cubit_Client::init (int argc, char **argv) +{ + this->argc_ = argc; + this->argv_ = argv; + + int check = 0; + + try { + // Parse command line and verify parameters. + if (this->parse_args () == -1) + return -1; + + // Retrieve the ORB. + this->orb_ptr_ = CORBA::ORB_init (this->argc_, + this->argv_); + + // @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("ORB initialization"); + return -1; + } + + // Retrieve a factory objref. + this->objref_ = this->orb_ptr_->resolve_initial_references ("Cubit_Factory"); + // @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("Cubit_Factory::_bind"); + return -1; + } + + if (CORBA::is_nil (this->objref_) == CORBA_TRUE) + ACE_ERROR_RETURN ((LM_ERROR, + "resolve_initial_references returned null object for Cubit_Factory\n"), + -1); + + // Narrow the CORBA::Object reference to the stub object + this->factory_ = Cubit_Factory::_narrow (this->objref_); + + //, this->env_); @@ put exception handling here !! + + CORBA::release (this->objref_); + + if (this->factory_ == 0) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to narrow object reference to a Cubit_Factory_ptr.\n"), + -1); + + // Now retrieve the Cubit obj ref corresponding to the key. + this->cubit_ = this->factory_->make_cubit (this->cubit_key_); + //, this->env_); @@ put exception handling here !! + + if (this->env_.exception () != 0) + { + // this->env_.print_exception ("string2object"); + return -1; + } + + if (CORBA::is_nil (this->cubit_)) + ACE_ERROR_RETURN ((LM_ERROR, + "null cubit objref returned by factory\n"), + -1); + } + catch(const CORBA::SystemException& exc) + { + ACE_DEBUG ((LM_DEBUG, + "CORBA::SystemException caught: %s (minor: %d): clnt.cpp\n\n", + exc._repository_id (), + exc.minor ())); + } + catch(const CORBA::UserException& exc) + { + ACE_DEBUG ((LM_DEBUG, + "CORBA::UserException caught: %s: clnt.cpp\n\n", + exc._repository_id ())); + } + catch(...) + { + ACE_DEBUG ((LM_DEBUG, + "Exception caught: clnt.cpp\n\n")); + } + + return 0; +} + +// This function runs the test. + +int +main (int argc, char **argv) +{ + Cubit_Client cubit_client; + + if (cubit_client.init (argc, argv) == -1) + return 1; + else + return cubit_client.run (); +} diff --git a/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/clnt.h b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/clnt.h new file mode 100644 index 00000000000..5713668e0e5 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/clnt.h @@ -0,0 +1,135 @@ +// $Id$ +// -*- C++ -*- +// ============================================================================ +// +// = LIBRARY +// TAO/tests/Cubit/CORBAplus/IDL_Cubit +// +// = FILENAME +// clnt.h +// +// = DESCRIPTION +// This class implements a simple "cube" CORBA client for the Cubit +// example using stubs generated by the TAO ORB IDL compiler. +// +// = AUTHORS +// Andy Gokhale, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ +#if !defined (_CLNT_H_) +#define _CLNT_H_ + +#include "ace/Get_Opt.h" +#include "pbroker/corba/orb.h" +#include "pbroker/corba/request.h" +#include "pbroker/corba/environ.h" +#include "cubit.h" + +class Cubit_Client + // = TITLE + // Defines a class that encapsulates behaviour of the Cubit client + // example. Provides a better understanding of the logic in an + // object oriented way. + // + // = DESCRIPTION + // This class declares an interface to run the example client for + // Cubit CORBA server. All the complexity for initializing the + // server is hidden in the class. Just the run() interface is needed. +{ + public: + // = Constructor and destructor. + Cubit_Client (void); + ~Cubit_Client (void); + + int run (void); + // Execute client example code. + + int init (int argc, char **argv); + // Initialize the client communication endpoint with server. + +private: + int func (u_int i); + // simple function that returns the substraction of 117 from the parameter. + + int parse_args (void); + // Parses the arguments passed on the command line. + + void print_stats (const char *call_name, ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time); + // prints the time stats + + void cube_union_stub (void); + // Exercise the union. Cube a union. + + void cube_union_dii (void); + // Exercise the union using dii. + + void cube_struct (int i); + // calculate the cube from a struct. + + void cube_long (int i); + // calculate the cube from a long + + void cube_octet (int i); + // Cube an octet + + void cube_short (int i); + // Cube a short. + + void cube_struct_dii (void); + // Cube the numbers in a struct + + int argc_; + // # of arguments on the command line. + + char **argv_; + // arguments from command line. + + const char *cubit_factory_key_; + // Key of factory obj ref. + + char *cubit_key_; + // Key of the obj ref to be retrieved via the factory. + + char *hostname_; + // Hostname of server. + + CORBA::ULong portnum_; + // default port number of server. + + u_int loop_count_; + // Number of times to do the cube operations. + + int exit_later_; + // Flag to tell server to not exit immediately + + Cubit_Factory_ptr factory_; + // factory pointer for cubit. + + CORBA::Object_ptr objref_; + // storage of the factory objref + + CORBA::Environment env_; + // Environment variable + + Cubit_ptr cubit_; + // Cubit obj ref + + CORBA::ORB_ptr orb_ptr_; + // Remember our orb + + u_int call_count_; + // # of calls made to functions + + u_int error_count_; + // # of errors incurred in the lifetime of the application. +}; + +#if defined (DEBUG) +#define dmsg1(X) { if (_debug_level > 0) ACE_DEBUG (X); } +#define dmsg2(X) { if (_debug_level > 1) ACE_DEBUG (X); } +#else +#define dmsg1(X) { } +#define dmsg2(X) { } +#endif /* DEBUG */ + +#endif /* _CLNT_H_ */ diff --git a/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit.idl b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit.idl new file mode 100644 index 00000000000..9ddc2d8954f --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit.idl @@ -0,0 +1,71 @@ +// $Id$ + +interface Cubit + // = TITLE + // Defines an interface that encapsulates operations that cube + // numbers. + // + // = DESCRIPTION + // This interface encapsulates operations that cube + // octets, shorts, longs, structs and unions. + +{ + octet cube_octet (in octet o); + // cube an octet + + short cube_short (in short s); + // cube a short + + long cube_long (in long l); + // cube a long + + struct Many + { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + // Cube a struct + + enum discrim + { + e_0th, + e_1st, + e_2nd, + e_3rd + }; + // Enumeration of the different elements in a union. + + union oneof switch (discrim) + { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + Many cm; + + // default: + // Many cm; + }; + // Union of different types. + + oneof cube_union (in oneof values); + // cube a union. + + oneway void please_exit (); + // shutdown the application. +}; + +interface Cubit_Factory + // = TITLE + // Creates Cubit objects +{ + Cubit make_cubit (in string key); +}; diff --git a/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit_i.cpp b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit_i.cpp new file mode 100644 index 00000000000..2eb422b10f8 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit_i.cpp @@ -0,0 +1,174 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/Cubit/CORBAplus/IDL_Cubit +// +// = FILENAME +// cubit_i.cpp +// +// = AUTHOR +// Sergio Flores-Gaitan +// +// ============================================================================ + +#include "pbroker/corba/orb.h" +#include "pbroker/corba/environ.h" +#include <pbroker/corba/xpsboa.h> +#include <pbroker/corba/lifecycl/impldecl.h> +#include "cubit_i.h" + +ACE_RCSID(IDL_Cubit, cubit_i, "$Id$") + +// Declare the Implementation +XPS_DECLARE_IMPLEMENTATION_ID(Cubit_Factory_iId,"Cubit_Factory_iId") +XPS_DECLARE_IMPLEMENTATION(Cubit_Factory_decl,Cubit_Factory_iId,Cubit_Factory) + +// Declare the associated activator, +XPS_DECLARE_DEFAULT_ACTIVATOR(Cubit_Factory_decl,Cubit_FactoryDefActivator,Cubit_Factory,Cubit_Factory_i) + +XPS_CAST1_IMPL(Cubit_Factory_i,Cubit_Factory_base_impl) + +// Constructor + +Cubit_Factory_i::Cubit_Factory_i (const char *key, int numobjs) + :numobjs_ (numobjs) +{ + // Create implementation object with user specified key. + this->my_cubit_ = new Cubit_i_ptr [this->numobjs_]; + + static char obj_str [MAXNAMELEN]; + + for (u_int i = 0; i < this->numobjs_; i++) + { + ACE_OS::memset (obj_str, '\0', MAXNAMELEN); + ACE_OS::sprintf (obj_str, "key%d", i); + + my_cubit_[i] = new Cubit_i (obj_str); + + if (my_cubit_[i] == 0) + ACE_ERROR ((LM_ERROR, + " (%P|%t) Unable to create implementation object%d\n", + i)); + } +} + +// Destructor + +Cubit_Factory_i::~Cubit_Factory_i (void) +{ + ACE_DEBUG ((LM_DEBUG, "~~~ in destructor ~Cubit_Factory_i()\n")); + delete [] this->my_cubit_; +} + +Cubit_ptr +Cubit_Factory_i::make_cubit (const char *key) +{ + CORBA_Environment env; + + for (size_t i = 0; i < this->numobjs_; i++) + { + const char *obj_str = this->my_cubit_[i]->_get_name (); + + // Keys matched. + if (!ACE_OS::strcmp (obj_str, key)) + return Cubit::_duplicate (this->my_cubit_ [i]); + } + + return Cubit::_nil (); +} + +// Constructor + +Cubit_i::Cubit_i (const char *obj_name) + : key_(obj_name) +{ +} + +const char * +Cubit_i::_get_name (void) +{ + return key_; +} + +// Destructor + +Cubit_i::~Cubit_i (void) +{ +} + +// Cube an octet + +CORBA::Octet +Cubit_i::cube_octet (CORBA::Octet o) +{ + return o * o * o; +} + +// Cube a short. + +CORBA::Short +Cubit_i::cube_short (CORBA::Short s) +{ + return s * s * s; +} + +// Cube a long + +CORBA::Long +Cubit_i::cube_long (CORBA::Long l) +{ + return l * l * l; +} + +// Cube a struct + +Cubit::Many +Cubit_i::cube_struct (const Cubit::Many &values) +{ + Cubit::Many temp; + + temp.o = values.o * values.o * values.o; + temp.s = values.s * values.s * values.s; + temp.l = values.l * values.l * values.l; + + return temp; +} + +// Cube a union + +Cubit::oneof +Cubit_i::cube_union (const Cubit::oneof &values) +{ + Cubit::oneof temp; + + switch (values._d ()) + { + case e_0th: + temp.o (values.o () * values.o () * values.o ()); + break; + case e_1st: + temp.s (values.s () * values.s () * values.s ()); + break; + case e_2nd: + temp.l (values.l () * values.l () * values.l ()); + break; + case e_3rd: + default: + temp._d (values._d ()); // set the discriminant + // use the read/write accessor + temp.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o; + temp.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s; + temp.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l; + + } + return temp; +} + +// Shutdown. + +void Cubit_i::please_exit (void) +{ + ACE_DEBUG ((LM_DEBUG, "I've been asked to shut down...\n")); +} diff --git a/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit_i.h b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit_i.h new file mode 100644 index 00000000000..b97c92c2e7d --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/cubit_i.h @@ -0,0 +1,107 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/Cubit/CORBAplus/IDL_Cubit +// +// = FILENAME +// cubit_i.h +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee and Sergio Flores-Gaitan +// +// ============================================================================ + +#if !defined (_CUBIT_I_HH) +#define _CUBIT_I_HH + +#include <pbroker/corba/lifecycl/actvtr.h> +#include <pbroker/corba/lifecycl/impldecl.h> + +#include "ace/OS.h" +#include "cubit_s.h" + +// Forward declarations +class Cubit_i; + +// Typedefs. +typedef Cubit_i *Cubit_i_ptr; +typedef Cubit_i_ptr Cubit_i_ref; + +class Cubit_i : public Cubit_base_impl + // = TITLE + // Illustrates how to integrate a servant with the + // generated skeleton. + // = DESCRIPTION + // Implementation of the cubit example at the servant side. + // Cubes an octet, short, long, struct and union. +{ +public: + Cubit_i (const char *obj_name = 0); + // Constructor + + ~Cubit_i (void); + // Destructor + + virtual CORBA::Octet cube_octet (CORBA::Octet o); + // Cube an octet + + virtual CORBA::Short cube_short (CORBA::Short s); + // Cube a short + + virtual CORBA::Long cube_long (CORBA::Long l); + // Cube a long + + virtual Cubit::Many cube_struct (const Cubit::Many &values); + // Cube a struct. + + virtual Cubit::oneof cube_union (const Cubit::oneof &values); + // Cube a union. + + virtual void please_exit (void); + // Shutdown routine. + + const char *_get_name (void); + // get the key of the object. + private: + const char *key_; +}; + + +class Cubit_Factory_i; + +typedef Cubit_Factory_i *Cubit_Factory_i_ptr; + +class Cubit_Factory_i: public Cubit_Factory_base_impl + // =TITLE + // Cubit_Factory_i + // + // DESCRIPTION + // factory object returning the cubit objrefs +{ +public: + XPS_CAST1_DECL(Cubit_Factory_i,Cubit_Factory_base_impl) + XPS_DEFINE_IMPLEMENTATION(Cubit_Factory_decl) + + Cubit_Factory_i (void) + {Cubit_Factory_i ("keyone", 1);} + + Cubit_Factory_i (const CORBA_ReferenceData & refData) + {Cubit_Factory_i ("keyone", 1);} + + Cubit_Factory_i (const char *key, int numobjs); + // constructor + + ~Cubit_Factory_i (void); + // destructor + + virtual Cubit_ptr make_cubit (const char *key); + // make the cubit object whose key is "key" + +private: + Cubit_i_ptr *my_cubit_; + u_int numobjs_; +}; + +#endif /* _CUBIT_I_HH */ diff --git a/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/svr.cpp b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/svr.cpp new file mode 100644 index 00000000000..5b66fc448ca --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/IDL_Cubit/svr.cpp @@ -0,0 +1,143 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/Cubit/CORBAplus/IDL_Cubit +// +// = FILENAME +// svr.cpp +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "ace/Get_Opt.h" +#include "ace/Log_Msg.h" +#include "pbroker/corba/orb.h" +#include "pbroker/corba/environ.h" +#include "pbroker/pberr.h" +#include <pbroker/corba/xpsorb.h> +#include <pbroker/corba/xpsboa.h> +#include "pbroker/corba/boad/boafull.h" // will force usage of "Full" BOA API + +#include <pbroker/unixsvc/unixsvc.h> + +#include "cubit_i.h" + +ACE_RCSID(IDL_Cubit, svr, "$Id$") + +// Global Variables +static int num_of_objs = 1; +static pbbool killSelf = pbfalse; + +// Declare the server activation policy +XPS_DECLARE_SERVER(Cubit_Factory,"Cubit_Factory",SHARED_SERVER) + +// Parses the command line arguments and returns an error status + +static int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt get_opts (argc, argv, "dn:"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'd': // debug flag + break; + case 'n': // number of cubit objects we hold + num_of_objs = ACE_OS::atoi (get_opts.optarg); + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-d]" + " [-n] <num of cubit objects>" + "\n", argv [0]), 1); + } + + return 0; // Indicates successful parsing of command line +} + +// Standard command line parsing utilities used. + +int +main (int argc, char *argv[]) +{ + CORBA_Environment env; + // char *orb_name = "internet"; + + XpsORB_ptr orb_ptr = XpsORB::_nil(); + XpsBOA * oa_ptr = XpsBOA::_nil (); + CORBA_Object_ptr obj_ptr = CORBA_Object::_nil(); + + try + { + // Initialize the ORB pointer + orb_ptr = XpsORB::init (argc, argv); + + // Initialize the Object Adapter + oa_ptr = XpsBOA::init (argc, argv); + + if (CORBA::is_nil(orb_ptr) || CORBA::is_nil(oa_ptr)) + { + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize the ORB and/or the BOA\n"), + 1); + } + + + // Parse remaining command line and verify parameters. + // parse_args (argc, argv); + + // create a factory implementation + Cubit_Factory_ptr factory; + + ACE_NEW_RETURN (factory, Cubit_Factory_i ("factory", num_of_objs), 1); + + // Stringify the objref we'll be implementing, and print it to + // stdout. Someone will take that string and give it to a + // client. Then release the object. + + CORBA::String str = 0; + + str = orb_ptr->object_to_url (factory); + + ACE_DEBUG ((LM_DEBUG, "listening as object '%s'\n", str)); + CORBA_string_free (str); + + oa_ptr->obj_is_ready (factory, nil); + oa_ptr->registerAlias (factory, "cubit_factory"); + + XpsEventService eventService; + eventService.mainloop(); // control will not return to this point + } + catch(const CORBA::SystemException& exc) + { + ACE_DEBUG ((LM_DEBUG, + "CORBA::SystemException caught: %s (minor: %d): svr.cpp\n\n", + exc._repository_id (), + exc.minor ())); + } + catch(const CORBA::UserException& exc) + { + ACE_DEBUG ((LM_DEBUG, + "CORBA::UserException caught: %s: svr.cpp\n\n", + exc._repository_id ())); + } + catch(...) + { + ACE_DEBUG ((LM_DEBUG, + "Exception caught: svr.cpp\n\n")); + } + + // Free resources + CORBA::release (oa_ptr); + CORBA::release (orb_ptr); + + return 0; +} diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/Makefile b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/Makefile new file mode 100644 index 00000000000..edc6dd9d8f9 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/Makefile @@ -0,0 +1,23 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the TAO MT-Cubit tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +DIRS = client \ + server + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nolocal.GNU + diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/README b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/README new file mode 100644 index 00000000000..a27939bd690 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/README @@ -0,0 +1,58 @@ +The MT-Cubit example +-------------------- + +Compiling +--------- + +Makefiles are provided. Use make to compile. + +You can either run the server in the background in the same window as +the client or open a separate window for the client and server. + +server: +------- + +./svr -pbtrace + +port_num is the port number at which the server will start the high +priority servant. The low priority servant will be created at +(port_num+1). + +The server will print the IOR of the high and low priority servants, +but it is not required by the client. + +client: +------- + +./client -d <datatype> -n <num_calls> -t <num_threads> -pbtrace -pbinit Cubit iiop://<remoteHost>:<port>/Cubit00 + +<datatype> is one of the following: + +0 Octet +1 Short +2 Long +3 Struct of the above 3 types + +<port_num> is the port number of the high priority servant. The low +priority servant is assumed to be at (port_num+1). + +<server_hostname> is the hostname of the server. + +Based on the server_hostname and the port_num, the client constructs +the IOR's for the high priority servant and the low priority servant. + +<num_calls> is the number of CORBA twoway calls to be made + +<num_threads> is the total number of concurrent clients to be +created. One of these clients will be a high priority client (and thus +send requests to the high priority servant), and the rest will have +low priority. + +The high priority client makes requests at 20Hz, and the low priority +clients make requests at 10Hz. + +Results +------- + +The client prints the latency observed by the high priority client, +and the average latency observed by the low priority client. diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Makefile b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Makefile new file mode 100644 index 00000000000..9441697f2d5 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Makefile @@ -0,0 +1,145 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Top-level Makefile for the ACE-ified Sun Ref. implementation +# of IIOP ORB +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +LDLIBS = -lmtcorba -lmtunixsvc -lmtpbroker -lmtboadc -lmtnaming -lmtlifecycl -lmtfsstream + +IDL_SRC = cubit.cpp +PROG_SRCS = $(IDL_SRC) Task_Client.cpp client.cpp + +LSRC = $(PROG_SRCS) + +CUBIT_CLIENT_OBJS = cubit.o Task_Client.o client.o + +BIN = client +BUILD = $(BIN) +VLDLIBS = $(LDLIBS:%=%$(VAR)) +VBIN = $(BIN:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +#enable C++ exceptions +exceptions = 1 + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +#include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +LDFLAGS += -L$(PBHOME)/lib +CPPFLAGS += -I$(PBHOME)/include + +$(IDL_SRC): cubit.idl + $(PBHOME)/bin/idlc cubit.idl + -/bin/mv cubit.C cubit.cpp + +client: $(addprefix $(VDIR),$(CUBIT_CLIENT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(PBHOME)/lib/mtiiop_s.o $(VLDLIBS) $(POSTLINK) + +clean: + -/bin/rm -rf *.o $(BIN) obj.* core Templates.DB .make.state + +realclean: clean + -/bin/rm -rf cubit.cpp cubit.h cubit_s.* + + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubit.o .shobj/cubit.: cubit.cpp +.obj/Task_Client.o .shobj/Task_Client.: Task_Client.cpp Task_Client.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Version.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i cubit.h \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Task_Client.cpp b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Task_Client.cpp new file mode 100644 index 00000000000..4f5e72b36ad --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Task_Client.cpp @@ -0,0 +1,359 @@ +// $Id$ + +#include "pbroker/corba/xpsorb.h" +#include "pbroker/corba/xpsboa.h" +#include "pbroker/corba/boad/boafull.h" // will force usage of "Full" BOA API +#include "Task_Client.h" + +ACE_RCSID(client, Task_Client, "$Id$") + +Task_State::Task_State (int argc, char **argv) + : start_count_ (0), + loop_count_ (5), + thread_count_ (5), + base_port_ (5000), + datatype_ (CB_OCTET), + argc_ (argc), + argv_ (argv) +{ + ACE_OS::strcpy (server_host_, "localhost"); + ACE_Get_Opt opts (argc, argv, "h:n:t:p:d:"); + int c; + int datatype; + + while ((c = opts ()) != -1) + switch (c) { + case 'd': + datatype = ACE_OS::atoi (opts.optarg); + switch (datatype) + { + case CB_OCTET: + ACE_DEBUG ((LM_DEBUG, "Testing Octets\n")); + datatype_ = CB_OCTET; + break; + case CB_LONG: + ACE_DEBUG ((LM_DEBUG, "Testing Longs\n")); + datatype_ = CB_LONG; + break; + case CB_STRUCT: + ACE_DEBUG ((LM_DEBUG, "Testing Structs\n")); + datatype_ = CB_STRUCT; + break; + case CB_SHORT: + default: + datatype_ = CB_SHORT; + ACE_DEBUG ((LM_DEBUG, "Testing Shorts\n")); + break; + } + continue; + case 'h': + ACE_OS::strcpy (server_host_, opts.optarg); + continue; + case 'p': + base_port_ = ACE_OS::atoi (opts.optarg); + continue; + case 'n': // loop count + loop_count_ = (unsigned) ACE_OS::atoi (opts.optarg); + continue; + case 't': + thread_count_ = (unsigned) ACE_OS::atoi (opts.optarg); + continue; + case '?': + default: + ACE_OS::fprintf (stderr, "usage: %s" + "[-d datatype Octet=0, Short=1, Long=2, Struct=3]" + " [-n num_calls]" + " [-h server_hostname]" + " [-p server_port_num]" + " [-t num_threads]" + "\n", argv [0] + ); + } + barrier_ = new ACE_Barrier (thread_count_); + latency_ = new double [thread_count_]; +} + +Client::Client (Task_State *ts) + : ACE_Task<ACE_MT_SYNCH> (ACE_Thread_Manager::instance ()), + ts_ (ts) +{ +} + +void +Client::put_latency (double latency, u_int thread_id) { + ts_->lock_.acquire (); + ts_->latency_[thread_id] = latency; + ACE_DEBUG ((LM_DEBUG, "(%t) My latency was %f\n", latency)); + ts_->lock_.release (); +} + +double +Client::get_high_priority_latency () { + return (double) ts_->latency_ [0]; +} + +double +Client::get_low_priority_latency () { + double l = 0; + for (u_int i = 1; i < ts_->start_count_; i++) + l += (double) ts_->latency_[i]; + return l / (double) (ts_->start_count_ - 1); +} + +int +Client::svc (void) +{ + ACE_DEBUG ((LM_DEBUG, "(%t) Thread created\n")); + u_int thread_id; + Cubit_ptr cb; + char ior [1024]; + double frequency; + XpsORB_ptr orb_ptr = XpsORB::_nil(); + // XpsBOA * oa_ptr = XpsBOA::_nil (); + //CORBA_Object_ptr obj_ptr = CORBA_Object::_nil(); + // CORBA::ORB_ptr orb_ptr; + try { + { + ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, ts_->lock_, -1); + + thread_id = ts_->start_count_; + ts_->start_count_++; + + if (thread_id == 0) + { + ACE_DEBUG ((LM_DEBUG, "(%t) Im the high priority client, my id is %d.\n", thread_id)); + ::sprintf (ior, "iiop:1.0//%s:%d/Cubit00", ts_->server_host_, ts_->base_port_); + frequency = CB_HIGH_PRIORITY_RATE; + } + else + { + ACE_DEBUG ((LM_DEBUG, "(%t) Im a low priority client, my id is %d\n", thread_id)); + ::sprintf (ior, "iiop:1.0//%s:%d/Cubit00", ts_->server_host_, ts_->base_port_ + 1); + frequency = CB_LOW_PRIORITY_RATE; + } + + ACE_DEBUG ((LM_DEBUG, "Using ior = %s\n", ior)); + + CORBA::Object_ptr objref = CORBA::Object::_nil (); + CORBA::Environment env; + + orb_ptr = XpsORB::init (ts_->argc_, ts_->argv_); + //orb_ptr = CORBA::ORB_init (ts_->argc_, ts_->argv_); + //if (env.exception () != 0) @@ put exception handling here !! + // ACE_ERROR_RETURN ((LM_ERROR,"%s:ORB initialization", env.exception ()), 2); + + // Retrieve a factory objref. + objref = orb_ptr->resolve_initial_references ("Cubit"); + + if (CORBA::is_nil (objref) == CORBA_TRUE) + ACE_ERROR_RETURN ((LM_ERROR, + "%s: must identify non-null target objref\n", + ts_->argv_ [0]), + 1); + + // Narrow the CORBA::Object reference to the stub object, checking + // the type along the way using _is_a. + cb = Cubit::_narrow (objref); + + if (cb == NULL) + { + ACE_ERROR_RETURN ((LM_ERROR, "Create cubit failed\n"), 1); + } + ACE_DEBUG ((LM_DEBUG, "(%t) Binding succeeded\n")); + ACE_DEBUG ((LM_DEBUG, "(%t) Cb == %x\n", cb)); + + CORBA::String str; + + str = orb_ptr->object_to_url (cb); + // + //ACE_ERROR_RETURN ((LM_ERROR, "object_to_string\n"), -1); + + ACE_OS::puts ((char *) str); + ACE_OS::fflush (stdout); + ACE_DEBUG ((LM_DEBUG, "Object Created at: '%ul'", cb)); + ACE_DEBUG ((LM_DEBUG, "connected to object '%s'", str)); + // if (cb->cube_short (2, env) == 8) // dummy call. + // ACE_DEBUG ((LM_DEBUG, "(%t) Made successful dummy call")); + } + + ACE_DEBUG ((LM_DEBUG, "(%t) Waiting for other threads to finish binding..\n")); + ts_->barrier_->wait (); + ACE_DEBUG ((LM_DEBUG, "(%t) Everyone's done, here I go!!\n")); + + this->run_tests (cb, ts_->loop_count_, thread_id, ts_->datatype_, frequency); + + // Free resources + CORBA::release (orb_ptr); + } + catch(const CORBA::SystemException& exc) + { + ACE_DEBUG ((LM_DEBUG, + "CORBA::SystemException caught: %s (minor: %d): client.cpp\n\n", + exc._repository_id (), + exc.minor ())); + } + catch(const CORBA::UserException& exc) + { + ACE_DEBUG ((LM_DEBUG, + "CORBA::UserException caught: %s: client.cpp\n\n", + exc._repository_id ())); + } + catch(...) + { + ACE_DEBUG ((LM_DEBUG, + "Exception caught: client.cpp\n\n")); + } + + return 0; +} + +int +Client::run_tests (Cubit_ptr cb, + u_int loop_count, + u_int thread_id, + Cubit_Datatypes datatype, + double frequency) +{ + CORBA::Environment env; + unsigned i = 0; + unsigned call_count = 0, error_count = 0; + + double latency = 0; + double sleep_time = (1/frequency) * (1000 * 1000); + double delta = 0; + + // + // Make the calls in a loop. + // + for (i = 0; i < loop_count; i++) + { + ACE_Profile_Timer timer; + ACE_Time_Value tv (0, (long int) (sleep_time - delta)); + ACE_OS::sleep (tv); + timer.start (); + + switch (datatype) + { + case CB_OCTET: + { + // Cube an octet. + call_count++; + + CORBA::Octet arg_octet = func (i), ret_octet = 0; + + ret_octet = cb->cube_octet (arg_octet); + + if (env.exception () != 0) + { + ACE_ERROR_RETURN ((LM_ERROR,"%s:Call failed\n", env.exception ()), 2); + } + arg_octet = arg_octet * arg_octet * arg_octet; + if (arg_octet != ret_octet) + { + ACE_OS::printf ("** cube_octet(%d) (--> %d)\n", arg_octet , ret_octet); + error_count++; + } + } + break; + + case CB_SHORT: + // Cube a short. + { + call_count++; + + CORBA::Short arg_short = func (i), ret_short; + + ret_short = cb->cube_short (arg_short); + + if (env.exception () != 0) + ACE_ERROR_RETURN ((LM_ERROR,"%s:Call failed\n", env.exception ()), 2); + + arg_short = arg_short * arg_short * arg_short; + if (arg_short != ret_short) { + ACE_OS::printf ("** cube_short(%d) (--> %d)\n", arg_short , ret_short); + error_count++; + } + } + break; + // Cube a long. + + case CB_LONG: + { + call_count++; + + CORBA::Long arg_long = func (i), ret_long; + + ret_long = cb->cube_long (arg_long); + + if (env.exception () != 0) + ACE_ERROR_RETURN ((LM_ERROR,"%s:Call failed\n", env.exception ()), 2); + + arg_long = arg_long * arg_long * arg_long; + if (arg_long != ret_long) + { + ACE_OS::printf ("** cube_long(%d) (--> %d)\n", arg_long , ret_long); + error_count++; + } + } + break; + + case CB_STRUCT: + // Cube a "struct" ... + { + Cubit::Many arg_struct, ret_struct; + + call_count++; + + arg_struct.l = func (i); + arg_struct.s = func (i); + arg_struct.o = func (i); + + ret_struct = cb->cube_struct (arg_struct); + + if (env.exception () != 0) + ACE_ERROR_RETURN ((LM_ERROR,"%s:Call failed\n", env.exception ()), 2); + + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l ; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s ; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o ; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o ) + { + ACE_OS::printf ("**cube_struct error!\n"); + error_count++; + } + + } + break; + } + timer.stop(); + ACE_Profile_Timer::ACE_Elapsed_Time et; + timer.elapsed_time (et); + delta = ( (0.4 * fabs (et.real_time * (1000 * 1000))) + (0.6 * delta) ); // pow(10,6) + latency += et.real_time; + } + + if (call_count > 0) + { + if (error_count == 0) + { + + latency /= call_count; + + if (latency > 0) { + ACE_OS::printf ("cube average call ACE_OS::time\t= %f msec, \t" + "%f calls/second\n", + latency * 1000, + 1 / latency); + this->put_latency (latency * 1000, thread_id); + } + + } + ACE_OS::printf ("%d calls, %d errors\n", call_count, error_count); + } + + // cb->please_exit (env); + return 0; +} diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Task_Client.h b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Task_Client.h new file mode 100644 index 00000000000..fa82b6a4d7b --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/Task_Client.h @@ -0,0 +1,52 @@ +// $Id$ + +#include "pbroker/corba/orb.h" +#include "pbroker/corba/request.h" +#include "pbroker/corba/environ.h" + +#include "ace/Synch.h" +#include "ace/Task.h" +#include "ace/Thread_Manager.h" +#include "ace/Get_Opt.h" +#include "cubit.h" +#include "ace/Profile_Timer.h" +#include <math.h> + +inline int func (unsigned i) { return i - 117; } + +enum Cubit_Datatypes {CB_OCTET, CB_SHORT, CB_LONG, CB_STRUCT}; + +#define CB_HIGH_PRIORITY_RATE 20 +#define CB_LOW_PRIORITY_RATE 10 + +class Task_State +{ + public: + ACE_Barrier *barrier_; + Task_State (int argc, char **argv); + unsigned int start_count_; + unsigned int loop_count_; + unsigned int thread_count_; + unsigned int base_port_; + char server_host_ [1024]; + double *latency_; + Cubit_Datatypes datatype_; + ACE_Thread_Mutex lock_; + int argc_; + char **argv_; +}; + +class Client : public ACE_Task<ACE_MT_SYNCH> +{ +public: + // Client (char *hostname, unsigned int n_threads, unsigned int loop_count_); + Client (Task_State *ts); + virtual int svc (void); + double get_high_priority_latency (); + double get_low_priority_latency (); +private: + int run_tests (Cubit_ptr, unsigned int, unsigned int, Cubit_Datatypes, double frequency); + void put_latency (double latency, unsigned int); + int parse_args (int, char **); + Task_State *ts_; +}; diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/client.cpp b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/client.cpp new file mode 100644 index 00000000000..d7716944625 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/client.cpp @@ -0,0 +1,63 @@ +// $Id$ + +//************************************************************************** +// +// NAME : client.C +// DESCRIPTION: +// +// Client for the Cubit example +// +//**************************************************************************** + +#include "ace/Task.h" +#include "ace/Thread_Manager.h" +#include "ace/Get_Opt.h" +#include "ace/Sched_Params.h" +#include "cubit.h" +#include "Task_Client.h" + +ACE_RCSID(client, client, "$Id$") + +// +// Mainline +// +int +main (int argc, char *argv[]) +{ + Task_State ts (argc, argv); + + ACE::set_handle_limit (); + + Client low_client (&ts); + + // First activate the high priority client. + + Client high_client (&ts); + + ACE_Sched_Priority priority = + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); + + ACE_DEBUG ((LM_DEBUG, "Creating client with high priority\n")); + + if (high_client.activate (THR_BOUND, 1, 0, priority) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed")); + + priority = + ACE_Sched_Params::priority_min (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); + + ACE_DEBUG ((LM_DEBUG, "Creating %d clients with low priority\n", ts.thread_count_ - 1)); + + if (low_client.activate (THR_BOUND, ts.thread_count_ - 1, 0, priority) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed")); + + + ACE_Thread_Manager::instance ()->wait (); + + ACE_OS::printf ("Test done.\n" + "High priority client latency : %f msec\n" + "Low priority client latency : %f msec\n", + high_client.get_high_priority_latency (), + low_client.get_low_priority_latency ()); + + return 0; +} diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/cubit.idl b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/cubit.idl new file mode 100644 index 00000000000..5ae02365ddf --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/client/cubit.idl @@ -0,0 +1,41 @@ +// $Id$ + + interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + /* enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + Many cm; + }; + + oneof cube_union (in oneof values); */ + + oneway void please_exit (); + }; + + + interface Cubit_Factory { + Cubit create_cubit (in short priority); + }; + diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/Makefile b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/Makefile new file mode 100644 index 00000000000..a992f98a221 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/Makefile @@ -0,0 +1,66 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Top-level Makefile for the ACE-ified Sun Ref. implementation +# of IIOP ORB +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +#LDLIBS = -lmtcorba -lmtunixsvc -lmtpbroker -lmtboadc -lmtnaming -lmtlifecycl -lmtfsstream +LDLIBS = -lcorba -lunixsvc -lpbroker -lboadc -lnaming -llifecycl -lfsstream + +IDL_SRC = cubit.cpp cubit_s.cpp +PROG_SRCS = svr.cpp cubit_i.cpp + +LSRC = $(IDL_SRC) $(PROG_SRCS) + +CUBIT_SVR_OBJS = cubit.o cubit_s.o svr.o cubit_i.o + +BIN = svr +BUILD = $(BIN) +VLDLIBS = $(LDLIBS:%=%$(VAR)) +VBIN = $(BIN:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +#enable C++ exceptions +exceptions = 1 + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +#include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +# Local modifications to variables imported by includes above. +LDFLAGS += -L$(PBHOME)/lib +CPPFLAGS += -I$(PBHOME)/include + +#CXX := purify $(CXX) + +$(IDL_SRC): cubit.idl + $(PBHOME)/bin/idlc cubit.idl + -/bin/mv cubit.C cubit.cpp + -/bin/mv cubit_s.C cubit_s.cpp + +svr: $(addprefix $(VDIR),$(CUBIT_SVR_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(PBHOME)/lib/iiop_s.o $(VLDLIBS) $(POSTLINK) + +clean: + -/bin/rm -rf *.o $(BIN) obj.* core Templates.DB .make.state + +realclean: clean + -/bin/rm -rf cubit.cpp cubit.h cubit_s.* +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubit.o .shobj/cubit.: cubit.cpp +.obj/cubit_s.o .shobj/cubit_s.: cubit_s.cpp + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit.idl b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit.idl new file mode 100644 index 00000000000..2ed3ec01499 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit.idl @@ -0,0 +1,41 @@ +// $Id$ + + interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + /* enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + Many cm; + }; + + oneof cube_union (in oneof values); */ + + oneway void please_exit (); + }; + + + interface Cubit_Factory { + Cubit create_cubit (in short priority); + }; + diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit_i.cpp b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit_i.cpp new file mode 100644 index 00000000000..e6883abba0c --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit_i.cpp @@ -0,0 +1,82 @@ +// $Id$ + +// @(#)cubit_i.cpp 05/14/97 +// Copyright 1994-1995 by Sun Microsystems Inc. +// All Rights Reserved +// +// TEST: hand-written Cubit Implementation +// +// Modified version of Cubit Example written by Sun Microsystems Inc. +// Modified by: Brian Mendel + +#include "pbroker/corba/orb.h" +#include "pbroker/corba/environ.h" +#include "cubit_i.h" + +ACE_RCSID(server, cubit_i, "$Id$") + +Cubit_i::Cubit_i (const char *obj_name) +{ +} + +Cubit_i::~Cubit_i (void) +{ +} + +CORBA::Octet +Cubit_i::cube_octet (CORBA::Octet o) +{ + return (CORBA::Octet) (o * o * o); +} + +CORBA::Short +Cubit_i::cube_short (CORBA::Short s) +{ + return (CORBA::Short) (s * s * s); +} + +CORBA::Long +Cubit_i::cube_long (CORBA::Long l) +{ + return (CORBA::Long) (l * l * l); +} + +Cubit::Many +Cubit_i::cube_struct (const Cubit::Many &values) +{ + Cubit::Many out_values; + out_values.o = values.o * values.o * values.o; + out_values.s = values.s * values.s * values.s; + out_values.l = values.l * values.l * values.l; + + return out_values; +} + +/*Cubit_oneof * +Cubit_i::cube_union (Cubit_oneof &values, + CORBA::Environment &env) +{ + ACE_UNUSED_ARG (env); + switch (values._disc) + { + case e_0th: + values.o = (CORBA::Octet) (values.o * values.o * values.o); + break; + case e_1st: + values.s = (CORBA::Short) (values.s * values.s * values.s); + break; + case e_2nd: + values.l = values.l * values.l * values.l; + break; + case e_3rd: + default: + values.cm.o = (CORBA::Octet) (values.cm.o * values.cm.o * values.cm.o); + values.cm.s = (CORBA::Short) (values.cm.s * values.cm.s * values.cm.s); + values.cm.l = values.cm.l * values.cm.l * values.cm.l; + } + return &values; +} */ + +void Cubit_i::please_exit (void) +{ +} diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit_i.h b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit_i.h new file mode 100644 index 00000000000..8ba58a1ccd7 --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/cubit_i.h @@ -0,0 +1,52 @@ +// $Id$ + +// @(#)cubit_i.cpp 05/14/97 +// Copyright 1994-1995 by Sun Microsystems Inc. +// All Rights Reserved +// +// TEST: hand-written Cubit Implementation +// +// Modified version of Cubit Example written by Sun Microsystems Inc. +// Modified by: Brian Mendel + +/************************************************************************** +This file has been hand-crafted to work with the ORB API of the SUN's IIOP +implementation +***************************************************************************/ + +#ifndef _CUBIT_I_HH +#define _CUBIT_I_HH + +#include "cubit_s.h" + +class Cubit_i; +typedef Cubit_i *Cubit_i_ptr; +typedef Cubit_i_ptr Cubit_i_ref; + +class Cubit_i : public Cubit_base_impl +{ +public: + Cubit_i (const char *obj_name = 0); + ~Cubit_i (void); + + virtual + CORBA::Octet cube_octet (CORBA::Octet o); + + virtual + CORBA::Short cube_short (CORBA::Short s); + + virtual + CORBA::Long cube_long (CORBA::Long l); + + virtual + Cubit::Many cube_struct (const Cubit::Many &values); + + /* virtual + Cubit::oneof *cube_union (Cubit::oneof &values, + CORBA::Environment &env); */ + + virtual + void please_exit (void); +}; + +#endif // _CUBIT_I_HH diff --git a/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/svr.cpp b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/svr.cpp new file mode 100644 index 00000000000..fbce11d56ab --- /dev/null +++ b/TAO/performance-tests/Cubit/CORBAplus/MT_Cubit/server/svr.cpp @@ -0,0 +1,288 @@ +// $Id$ + +// @(#)svr.cpp 05/14/97 +// Copyright 1994-1995 by Sun Microsystems Inc. +// All Rights Reserved +// +// TEST: simple IIOP server for "cubit.idl" interface. +// +// Starts up, builds an objref, prints its string in debug mode, +// listens for messages, responds to them. +// +// Modified version of Cubit Example written by Sun Microsystems Inc. +// Modified by: Brian Mendel + +#include "pbroker/corba/orb.h" +#include "pbroker/corba/request.h" +#include "pbroker/corba/environ.h" +#include "pbroker/unixsvc/unixsvc.h" +#include "pbroker/corba/xpsorb.h" +#include "pbroker/corba/xpsboa.h" +#include "pbroker/corba/boad/boafull.h" // will force usage of "Full" BOA API +#include "ace/Get_Opt.h" +#include "ace/Log_Msg.h" +#include "ace/Task.h" +#include "ace/ARGV.h" +#include "ace/Sched_Params.h" + +#include "cubit_i.h" + +ACE_RCSID(server, svr, "$Id$") + +// Global Variables +static CORBA::String key = (CORBA::String) "Cubit"; + + +class Cubit_Task : public ACE_Task<ACE_NULL_SYNCH> +// = TITLE +// Encapsulates an ORB for the Cubit application +{ +public: + Cubit_Task (const char* args, const char* orbname, unsigned int num_of_objs); // + + virtual int svc (void); + +protected: + Cubit_Task () {}; + +private: + char* orbname_; + char* orbargs_; + unsigned int num_of_objs_; +}; + +Cubit_Task::Cubit_Task (const char* args, const char* orbname, unsigned int num_of_objs) + : orbname_ ((char*)orbname), + orbargs_ ((char*)args), + num_of_objs_ (num_of_objs) +{} + + +int +Cubit_Task::svc (void) +{ + CORBA::Environment env; + ACE_DEBUG ((LM_DEBUG, "(%P|%t) Beginning Cubit task with args = '%s'\n", orbargs_)); + ACE_ARGV args (orbargs_); + + int argc = args.argc (); + char** argv = args.argv (); + + XpsORB_ptr orb_ptr = XpsORB::_nil(); + XpsBOA * oa_ptr = XpsBOA::_nil (); + CORBA_Object_ptr obj_ptr = CORBA_Object::_nil(); + + try { + // Initialize the ORB pointer + orb_ptr = XpsORB::init (argc, argv); + + // Initialize the Object Adapter + oa_ptr = XpsBOA::init (argc, argv); + + if (CORBA::is_nil(orb_ptr) || CORBA::is_nil(oa_ptr)) + { + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize the ORB and/or the BOA\n"), + 1); + } + + // Create implementation object with user specified key. + Cubit_i_ptr *my_cubit = new Cubit_i_ptr[num_of_objs_]; + + u_int i; + for (i = 0; i < num_of_objs_; i++) + { + CORBA::String obj_str = CORBA::string_alloc (ACE_OS::strlen ((char *) key)+30); + +#if 0 + ACE_OS::sprintf (obj_str, "%s-%u-%02d", (char *) key, ACE_Thread::self (), i); +#else + ACE_OS::sprintf (obj_str, "%s%02d", (char *) key, i); +#endif + + my_cubit[i] = new Cubit_i (obj_str); + + if (my_cubit[i] == 0) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to create implementation object&d\n", + i), + 2); + + //CORBA::OctetSeq obj_key; + //obj_key.buffer = (CORBA::Octet *) obj_str; + //obj_key.length = obj_key.maximum = ACE_OS::strlen (obj_str); + + //CORBA::Object_ptr obj = 0; + + // if (oa_ptr->find (obj_key, obj) == -1) + // ACE_ERROR_RETURN ((LM_ERROR, + // " (%P|%t) Unable to locate object with key '%s', %p\n", + // key), + // 3); + + // Stringify the objref we'll be implementing, and print it + // to stdout. Someone will take that string and give it to + // some client. Then release the object. + + CORBA::String str; + + // str = orb_ptr->object_to_string (obj); + str = orb_ptr->object_to_url (my_cubit[i]); + + ACE_DEBUG ((LM_DEBUG, "listening as object '%s'\n", str)); + CORBA_string_free (str); + + oa_ptr->obj_is_ready (my_cubit[i], nil); + oa_ptr->registerAlias (my_cubit[i], obj_str); + + if (env.exception () != 0) + { + // env.print_exception ("object2string"); + return 1; + } + + ACE_OS::puts ((char *) str); + ACE_OS::fflush (stdout); + //ACE_DEBUG ((LM_DEBUG,"Object Created at: '%ul'", obj)); + CORBA::string_free (obj_str); + } + + // Handle requests for this object until we're killed, or one of the + // methods asks us to exit. + XpsEventService eventService; + eventService.mainloop(); // control will not return to this point + // orb_ptr->run (); + + // Shut down the OA -- recycles all underlying resources (e.g. file + // descriptors, etc). + + // oa_ptr->clean_shutdown (env); + + // Need to clean up and do a CORBA::release on everything we've + // created! + for (i = 0; i < num_of_objs_; i++) + { + delete my_cubit[i]; + } + + // Free resources + CORBA::release (orb_ptr); + CORBA::release (oa_ptr); + } + catch(const CORBA::SystemException& exc) + { + ACE_DEBUG ((LM_DEBUG, + "CORBA::SystemException caught: %s (minor: %d): svr.cpp\n\n", + exc._repository_id (), + exc.minor ())); + } + catch(const CORBA::UserException& exc) + { + ACE_DEBUG ((LM_DEBUG, + "CORBA::UserException caught: %s: svr.cpp\n\n", + exc._repository_id ())); + } + catch(...) + { + ACE_DEBUG ((LM_DEBUG, + "Exception caught: svr.cpp\n\n")); + } + + return 0; +} + +static char *hostname = NULL; +static int base_port = 0; + +// Parses the command line arguments and returns an error status + +static int num_of_objs = 1; + +static int +parse_args (int argc, char *argv[]) +{ + ACE_Get_Opt opts (argc, argv, "h:p:n:"); + int c; + + while ((c = opts ()) != -1) + switch (c) + { + case 'h': + hostname = opts.optarg; + break; + case 'p': + base_port = ACE_OS::atoi (opts.optarg); + break; + case 'n': + num_of_objs = ACE_OS::atoi (opts.optarg); + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " -p port" + " -h my_hostname" + " -n num_objects" + "\n", argv [0]), 1); + } + + return 0; // Indicates successful parsing of command line +} + +// Standard command line parsing utilities used. + +int +main (int argc, char *argv[]) +{ + +#if 0 + parse_args (argc, argv); + + if ((hostname == NULL) || (base_port == 0)) + { + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s " + " -p port -h my_hostname" + "\n",argv [0]), 1); + + } +#endif + + const size_t arg_size = + strlen("rate20 -ORBport %d -ORBhost %s") + + 5 /* port number */ + + MAXHOSTNAMELEN /* hostname */ + + 1 /* zero terminator */; + + char *args1 = 0; + ACE_NEW_RETURN (args1, char[arg_size], -1); + + ::sprintf (args1, "rate20"); + Cubit_Task task1 (args1 , "internet", 1); + ACE_Sched_Priority priority; +#if defined(VXWORKS) + priority = ACE_Sched_Params::priority_max (ACE_SCHED_FIFO, ACE_SCOPE_THREAD) + 6; +#else + priority = ACE_Sched_Params::priority_max (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); +#endif + ACE_DEBUG ((LM_DEBUG, "Creating servant with high priority\n")); + task1.activate (THR_BOUND, 1, 0, priority); + + + char *args2 = 0; + ACE_NEW_RETURN (args2, char[arg_size], -1); + + ::sprintf (args2, "rate10");//, base_port+1, hostname); + Cubit_Task task2 (args2 , "internet", 1); + priority = + ACE_Sched_Params::priority_min (ACE_SCHED_FIFO, ACE_SCOPE_THREAD); + ACE_DEBUG ((LM_DEBUG, "Creating servant with low priority\n")); + task2.activate (THR_BOUND, 1, 0, priority); + + ACE_Thread_Manager::instance ()->wait (); + + delete [] args1; + delete [] args2; + + return 0; +} diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/Imakefile b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/Imakefile new file mode 100644 index 00000000000..633ac06056a --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/Imakefile @@ -0,0 +1,34 @@ +COMMENT @(#) (C) Copyright Lockheed Martin 1996, 1997, 1998 (Unpublished). All rights reserved. Imakefile 1.3 changed 5/22/98 13:34:14 + +BUILD=/project/doc/pkg/Hardpack/dsi_5.1/SunOS_5.5.1 +PREPRO = $(BUILD)/bin/idlpp_cc + +CCFLAGS += -mt -xildoff + +#if defined(T_SunOS) +INC=-I$(BUILD)/include -I$(ACE_ROOT) -I/usr/include -I/usr/include/sys +LIBS=$(BUILD)/Templates.DB/$()*.o -L$(BUILD)/lib -lORB++ -lORB -lES -L$(ACE_ROOT)/ace -lACE +#else +INC=-I$(BUILD)/include -I$(ACE_ROOT) -I/usr/include -I/usr/include/sys +LIBS=-L$(BUILD)/lib -lORB++ -lORB -lES -lIR++ -lACE -L$(ACE_ROOT)/ace +#endif + + +all: cubit.hh client server + +client: client.cpp client_i.cpp cubit_c.cc cubit.hh + $(CCC) $(CCFLAGS) $(INC) -o client \ + cubit_c.cc client_i.cpp client.cpp \ + $(LIBS) $(OSLIBS) + +server: server.cpp server_i.cpp cubit_impl.cc cubit_s.cc cubit_c.cc cubit.hh + $(CCC) $(CCFLAGS) $(INC) -o server \ + server.cpp server_i.cpp cubit_s.cc cubit_c.cc cubit_impl.cc \ + $(LIBS) $(OSLIBS) + +cubit.hh: cubit.idl + $(PREPRO) cubit.idl + +clean: + rm -f client server cubit.hh *_s.cc *_c.cc *.o; + rm -rf Templates.DB; rm -f *~ diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/Makefile b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/Makefile new file mode 100644 index 00000000000..a9713cf8083 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/Makefile @@ -0,0 +1,55 @@ +/* $Id$ */ +# Makefile generated by imake - do not edit! +# $XConsortium: imake.c,v 1.72 92/09/14 11:44:22 rws Exp $ +# +# The cpp used on this machine replaces all newlines and multiple tabs and +# spaces in a macro expansion with a single space. Imake tries to compensate +# for this, but is not always successful. +# + +CCC=CC +CC=cc + +CFLAGS=-g -D_DEBUG=3 -DDSI_DEBUG=3 $(INC) -xs -DBSD_COMP +CCFLAGS=-g -D_DEBUG=3 -DDSI_DEBUG=3 -D_IR_hh $(INC) -xs -DBSD_COMP -i +OSLIBS=-lthread -lposix4 -lsocket -lnsl -lm + +# @(#) (C) Copyright Lockheed Martin 1996, 1997, 1998 (Unpublished). All rights reserved. Imakefile 1.3 changed 5/22/98 13:34:14 + +BUILD=/project/doc/pkg/Hardpack/dsi_5.1/SunOS_5.5.1 +PREPRO = $(BUILD)/bin/idlpp_cc + +CCFLAGS += -mt -xildoff + +INC=-I$(BUILD)/include -I$(ACE_ROOT) -I/usr/include -I/usr/include/sys +LIBS=$(BUILD)/Templates.DB/$()*.o -L$(BUILD)/lib -lORB++ -lORB -lES -L$(ACE_ROOT)/ace -lACE + +all: cubit.hh client server + +client: client.cpp client_i.cpp cubit_c.cc cubit.hh + $(CCC) $(CCFLAGS) $(INC) -o client \ + cubit_c.cc client_i.cpp client.cpp \ + $(LIBS) $(OSLIBS) + +server: server.cpp server_i.cpp cubit_impl.cc cubit_s.cc cubit_c.cc cubit.hh + $(CCC) $(CCFLAGS) $(INC) -o server \ + server.cpp server_i.cpp cubit_s.cc cubit_c.cc cubit_impl.cc \ + $(LIBS) $(OSLIBS) + +cubit.hh: cubit.idl + $(PREPRO) cubit.idl + +clean: + rm -f client server cubit.hh *_s.cc *_c.cc *.o; + rm -rf Templates.DB; rm -f *~ + +.SUFFIXES: .cc + +.cc.a: + $(CCC) -c $(CCFLAGS) $< + $(AR) $(ARFLAGS) $@ $*.o + rm -f $*.o + +.cc: + $(CCC) $(CCFLAGS) $(LDFLAGS) $< -o $@ + diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/README b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/README new file mode 100644 index 00000000000..4a722a5c5d6 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/README @@ -0,0 +1,41 @@ +The IDL_Cubit test for Hardpack ORB +------------------------------------ + +Compiling +--------- + +setup the HARDPACK ROOT environment variables before compiling. + +The following is an example configuration for SunOS_5.5.1: + +setenv HARDPACK_ROOT /project/doc/pkg/Hardpack/dsi_5.1 +setenv PATH ${HARDPACK_ROOT}/bin:${HARDPACK_ROOT}/SunOS_5.5.1/bin:${PATH} +setenv LD_LIBRARY_PATH ${HARDPACK_ROOT}/SunOS_5.5.1/lib:${LD_LIBRARY_PATH} + +1. Hardpack provides a build tool to build the Makefile from the Imakefile. + +2.To build and compile + + $build SUN + + $build clean + will clean the object files and executables and also the Makefile. + +To Run: +------ + +1. Edit the initref.cfg file in this directory by putting the hostname +on which you want the name server to run. + +2. Run the Hardpack nameserver + + $nameserver + +3. Run the server + + $server + +4. Run the client + + $client + diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client.cpp b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client.cpp new file mode 100644 index 00000000000..e43c60643f0 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client.cpp @@ -0,0 +1,22 @@ +// $Id$ + +#include "client_i.h" + +ACE_RCSID(IDL_Cubit, client, "$Id$") + +// This function runs the test. + +int +main (int argc, char **argv) +{ + Cubit_Client cubit_client; + + ACE_DEBUG ((LM_DEBUG, + "\n \t IDL_Cubit: client \n\n")); + + if (cubit_client.init (argc, argv) == -1) + return 1; + else + return cubit_client.run (); +} + diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client_i.cpp b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client_i.cpp new file mode 100644 index 00000000000..073dbaca8a0 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client_i.cpp @@ -0,0 +1,824 @@ +// $Id$ + +#include "ace/Env_Value_T.h" +#include "ace/Read_Buffer.h" +#include "client_i.h" + +ACE_RCSID(IDL_Cubit, client_i, "$Id$") + +#if defined (ACE_ENABLE_TIMEPROBES) + +static const char *Cubit_Client_Timeprobe_Description[] = +{ + "Cubit_Client::cube_octet - start", + "Cubit_Client::cube_octet - end", + + "Cubit_Client::cube_short - start", + "Cubit_Client::cube_short - end", + + "Cubit_Client::cube_long - start", + "Cubit_Client::cube_long - end", + + "Cubit_Client::cube_struct - start", + "Cubit_Client::cube_struct - end", + + "Cubit_Client::cube_union - start", + "Cubit_Client::cube_union - end", + + "Cubit_Client::cube_long_sequence - start", + "Cubit_Client::cube_long_sequence - end", + + "Cubit_Client::cube_octet_sequence - start", + "Cubit_Client::cube_octet_sequence - end" +}; + +enum +{ + // Timeprobe description table start key + CUBIT_CLIENT_CUBE_OCTET_START = 10000, + CUBIT_CLIENT_CUBE_OCTET_END, + + CUBIT_CLIENT_CUBE_SHORT_START, + CUBIT_CLIENT_CUBE_SHORT_END, + + CUBIT_CLIENT_CUBE_LONG_START, + CUBIT_CLIENT_CUBE_LONG_END, + + CUBIT_CLIENT_CUBE_STRUCT_START, + CUBIT_CLIENT_CUBE_STRUCT_END, + + CUBIT_CLIENT_CUBE_UNION_START, + CUBIT_CLIENT_CUBE_UNION_END, + + CUBIT_CLIENT_CUBE_LONG_SEQUENCE_START, + CUBIT_CLIENT_CUBE_LONG_SEQUENCE_END, + + CUBIT_CLIENT_CUBE_OCTET_SEQUENCE_START, + CUBIT_CLIENT_CUBE_OCTET_SEQUENCE_END +}; + +// Setup Timeprobes +ACE_TIMEPROBE_EVENT_DESCRIPTIONS (Cubit_Client_Timeprobe_Description, + CUBIT_CLIENT_CUBE_OCTET_START); + +#endif /* ACE_ENABLE_TIMEPROBES */ + +// Constructor. +Cubit_Client::Cubit_Client (void) + : cubit_factory_key_ (0), + cubit_key_ (ACE_OS::strdup ("key0")), + loop_count_ (250), + shutdown_ (0), + cubit_ (Cubit::_nil ()), + call_count_ (0), + error_count_ (0), + cubit_factory_ior_file_ (0), + f_handle_ (ACE_INVALID_HANDLE), + use_naming_service_ (1) +{ +} + +// Simple function that returns the substraction of 117 from the +// parameter. + +int +Cubit_Client::func (u_int i) +{ + return i - 117; +} + +// Reads the Cubit factory ior from a file + +int +Cubit_Client::read_ior (char *filename) +{ + // Open the file for reading. + this->f_handle_ = ACE_OS::open (filename,0); + + if (this->f_handle_ == ACE_INVALID_HANDLE) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to open %s for writing: %p\n", + filename), + -1); + ACE_Read_Buffer ior_buffer (this->f_handle_); + this->cubit_factory_key_ = ior_buffer.read (); + + if (this->cubit_factory_key_ == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to allocate memory to read ior: %p\n"), + -1); + return 0; +} + +// Parses the command line arguments and returns an error status. + +int +Cubit_Client::parse_args (void) +{ + ACE_Get_Opt get_opts (argc_, argv_, "n:f:k:xs"); + int c; + int result; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'n': // loop count + this->loop_count_ = (u_int) ACE_OS::atoi (get_opts.optarg); + break; + case 'f': // read the IOR from the file. + result = this->read_ior (get_opts.optarg); + if (result < 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to read ior from %s : %p\n", + get_opts.optarg), + -1); + break; + case 'k': // read the cubit IOR from the command-line. + this->cubit_factory_key_ = + ACE_OS::strdup (get_opts.optarg); + break; + case 'x': + this->shutdown_ = 1; + break; + case 's': // Don't use the TAO Naming Service. + this->use_naming_service_ = 0; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-n loopcount]" + " [-f cubit_factory-obj-ref-key-file]" + " [-k cubit-obj-ref-key]" + " [-x]" + " [-s]" + "\n", + this->argv_ [0]), + -1); + } + + // Indicates successful parsing of command line. + return 0; +} + +// Exercise the union. Cube a union. + +// void +// Cubit_Client::cube_union (void) +// { +// Cubit::oneof u; + +// this->call_count_++; + +// u.l (3); // use the long union branch. + +// // Cube a "union" ... +// Cubit::oneof r; +// { +// ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START); + +// try +// { +// r = this->cubit_->cube_union (u); +// } +// catch (...) +// { +// cout << "An unknown exception in cube_long\n"; +// this->error_count_++; +// return; +// } +// } +// u.l (u.l () * u.l () * u.l ()) ; + +// if (u.l () != r.l ()) +// { +// ACE_DEBUG ((LM_DEBUG, "** cube_union ERROR\n")); +// this->error_count_++; +// } + +// this->call_count_++; + +// u._d (Cubit::e_3rd); + +// u.cm ().l = 7; +// u.cm ().s = 5; +// u.cm ().o = 3; + +// // Cube another "union" which uses the default arm ... NOT tested yet +// { +// ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START); +// try +// { +// r = this->cubit_->cube_union (u); +// } +// catch (...) +// { +// cout << "An unknown exception in cube_long\n"; +// this->error_count_++; +// return; +// } +// } +// u.cm ().l = u.cm ().l * u.cm ().l * u.cm ().l; +// u.cm ().s = u.cm ().s * u.cm ().s * u.cm ().s; +// u.cm ().o = u.cm ().o * u.cm ().o * u.cm ().o; + +// if (u.cm ().l != r.cm ().l +// || u.cm ().s != r.cm ().s +// || u.cm ().o != r.cm ().o) +// { +// ACE_DEBUG ((LM_DEBUG, "** cube_union ERROR\n")); +// this->error_count_++; +// } +// } + +// Cube a short. + +void +Cubit_Client::cube_short (int i) +{ + CORBA::Short arg_short = this->func (i); + + this->call_count_++; + // Cube a short. + CORBA::Short ret_short; + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_SHORT_START); + try + { + ret_short = this->cubit_->cube_short (arg_short); + } + catch (...) + { + cout << "An unknown exception in cube_short\n"; + this->error_count_++; + return; + } + arg_short = arg_short * arg_short * arg_short; + if (arg_short != ret_short) + { + ACE_ERROR ((LM_ERROR, "** cube_short (%d) ERROR (--> %d)\n", + (CORBA::Short) i-117, + ret_short)); + this->error_count_++; + } + } +} + +void +Cubit_Client::cube_oneway (int i) +{ + try + { + this->cubit_->cube_oneway (); + } + catch (...) + { + cout << "An unknown exception in cube_short\n"; + this->error_count_++; + return; + } + + this->call_count_++; + return; +} + +void +Cubit_Client::cube_void (int i) +{ + try + { + this->cubit_->cube_void (); + } + catch (...) + { + cout << "An unknown exception in cube_short\n"; + this->error_count_++; + return; + } + this->call_count_++; +} + + +// Cube an octet + +void +Cubit_Client::cube_octet (int i) +{ + CORBA::Octet arg_octet = this->func (i); + + this->call_count_++; + // Cube an octet. + CORBA::Octet ret_octet; + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_START); + try + { + ret_octet = this->cubit_->cube_octet (arg_octet); + } + catch (...) + { + cout << "An unknown exception in cube_long\n"; + this->error_count_++; + return; + } + arg_octet = arg_octet * arg_octet * arg_octet; + if (arg_octet != ret_octet) { + ACE_DEBUG ((LM_DEBUG, + "** cube_octet (%d) ERROR (--> %d)\n", + (CORBA::Octet) this->func (i), + ret_octet)); + this->error_count_++; + } + } +} + + // calculate the cube from a long + +void +Cubit_Client::cube_long (int i) +{ + CORBA::Long arg_long = this->func (i); + + // Cube a long. + CORBA::Long ret_long; + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_START); + try + { + ret_long = this->cubit_->cube_long (arg_long); + this->call_count_++; + } + catch (...) + { + cout << "An unknown exception in cube_long\n"; + this->error_count_++; + this->call_count_++; + return; + } + arg_long = arg_long * arg_long * arg_long; + if (arg_long != ret_long) + { + ACE_ERROR ((LM_ERROR, + "** cube_long (%ld) ERROR (--> %ld)\n", + (CORBA::Long) this->func (i), + ret_long)); + this->error_count_++; + } + } +} + +// // Cube the numbers in a struct + +void +Cubit_Client::cube_struct (int i) +{ + Cubit::Many arg_struct; + Cubit::Many ret_struct; + + this->call_count_++; + + arg_struct.l = this->func (i); + arg_struct.s = this->func (i); + arg_struct.o = this->func (i); + + // Cube a "struct" ... + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_STRUCT_START); + try + { + ret_struct = this->cubit_->cube_struct (arg_struct); + } + catch (...) + { + cout << "An unknown exception in cube_struct\n"; + this->error_count_++; + return; + } + } + + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o) + { + ACE_ERROR ((LM_ERROR, "** cube_struct ERROR\n")); + this->error_count_++; + } +} + + +// Cube the numbers in a sequence + +// void +// Cubit_Client::cube_long_sequence (int i, int l) +// { +// this->call_count_++; + +// Cubit::long_seq input (l); +// input.length (l); + +// // Just set the first item, otherwise it is hard to compare the +// // results for longer sequences, i.e. more than just marshalling +// // gets in the way. +// input[0] = 4; + +// Cubit::long_seq_var output ; + +// // Cube the sequence +// { +// ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_SEQUENCE_START); +// try +// { +// this->cubit_->cube_long_sequence (input,output); +// } +// catch (...) +// { +// cout << "An unknown exception in cube_long_sequence\n"; +// this->error_count_++; +// return; +// } +// } +// if (output->length () != input.length ()) +// { +// ACE_ERROR ((LM_ERROR, "** cube sequence, wrong length\n")); +// this->error_count_++; +// } + +// u_int rl = output->length (); +// if (input.length () < rl) +// rl = input.length (); +// CORBA::Long x = input[0]; +// if (x * x *x != output[0]) +// { +// ACE_ERROR ((LM_ERROR, "** cube_long_sequence ERROR\n")); +// this->error_count_++; +// } +// } + +// void +// Cubit_Client::cube_octet_sequence (int i, int l) +// { +// this->call_count_++; + +// Cubit::octet_seq input (l); +// input.length (l); + +// // Just set the first item, otherwise it is hard to compare the +// // results for longer sequences, i.e. more than just marshalling +// // gets in the way. +// input[0] = 4; + +// Cubit::octet_seq* output; + +// // Cube the sequence +// { +// ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_SEQUENCE_START); + +// try +// { +// this->cubit_->cube_octet_sequence (input, output); +// } +// catch (...) +// { +// cout << "An unknown exception in cube_octec_sequence\n"; +// this->error_count_++; +// return; +// } +// } +// u_int rl = output->length (); +// if (rl != input.length ()) +// { +// ACE_ERROR ((LM_ERROR, "** cube octet, wrong length\n")); +// this->error_count_++; +// } + +// if (input.length () < rl) +// rl = input.length (); +// CORBA::Octet x = input[0]; +// if (x * x *x != output[0]) +// { +// ACE_ERROR ((LM_ERROR, "** cube_octet ERROR\n")); +// this->error_count_++; +// } +// } + +void +Cubit_Client::print_stats (const char *call_name, + ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time) +{ + ACE_DEBUG ((LM_DEBUG, + "%s:\n", + call_name)); + + if (this->call_count_ > 0 && this->error_count_ == 0) + { +#if defined (ACE_LACKS_FLOATING_POINT) + // elapsed_time.real_time is in units of microseconds. + const u_int calls_per_sec = + this->call_count_ * 1000000u / elapsed_time.real_time; + + ACE_DEBUG ((LM_DEBUG, + "\treal_time\t= %u ms,\n" + "\t%u calls/second\n", + elapsed_time.real_time / 1000u, + calls_per_sec)); +#else /* ! ACE_LACKS_FLOATING_POINT */ + // elapsed_time.real_time is in units of seconds. + double calls_per_sec = this->call_count_ / elapsed_time.real_time; + + ACE_DEBUG ((LM_DEBUG, + "\treal_time\t= %0.06f ms, \n\t" + "user_time\t= %0.06f ms, \n\t" + "system_time\t= %0.06f ms\n" + "\t%0.00f calls/second\n", + elapsed_time.real_time < 0.0 ? 0.0 + : elapsed_time.real_time * ACE_ONE_SECOND_IN_MSECS, + elapsed_time.user_time < 0.0 ? 0.0 + : elapsed_time.user_time * ACE_ONE_SECOND_IN_MSECS, + elapsed_time.system_time < 0.0 ? 0.0 + : elapsed_time.system_time * ACE_ONE_SECOND_IN_MSECS, + calls_per_sec < 0.0 ? 0.0 : calls_per_sec)); +#endif /* ! ACE_LACKS_FLOATING_POINT */ + } + else + ACE_ERROR ((LM_ERROR, + "\tNo time stats printed. Call count zero or error ocurred.\n")); + + ACE_DEBUG ((LM_DEBUG, + "\t%d calls, %d errors\n", + this->call_count_, + this->error_count_)); +} + +// Execute client example code. + +int +Cubit_Client::run (int testing_collocation) +{ + u_int i; + + ACE_Profile_Timer timer; + ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time; + // ACE_Time_Value before; + + + // + // Show the results one type at a time. + // + + // ONEWAY + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_oneway (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_oneway", elapsed_time); + + // VOID + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_void (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_void", elapsed_time); + + // SHORT + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_short (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_short", elapsed_time); + + // OCTET + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_octet (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_octet", elapsed_time); + + // LONG + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_long (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_long", elapsed_time); + + // STRUCT + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_struct (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_struct", elapsed_time); + +// // UNION +// this->call_count_ = 0; +// this->error_count_ = 0; +// timer.start (); +// for (i = 0; i < this->loop_count_; i++) +// this->cube_union (); +// timer.stop (); +// timer.elapsed_time (elapsed_time); +// this->print_stats ("cube_union_stub call", elapsed_time); + +// // SMALL LONG SEQUENCES +// this->call_count_ = 0; +// this->error_count_ = 0; +// timer.start (); +// for (i = 0; i < this->loop_count_; i++) +// this->cube_long_sequence (this->loop_count_, 4); +// timer.stop (); +// timer.elapsed_time (elapsed_time); +// this->print_stats ("cube_small_sequence<long>", elapsed_time); + +// // LARGE LONG SEQUENCES +// this->call_count_ = 0; +// this->error_count_ = 0; +// timer.start (); +// for (i = 0; i < this->loop_count_; i++) +// this->cube_long_sequence (this->loop_count_, 1024); +// timer.stop (); +// timer.elapsed_time (elapsed_time); +// this->print_stats ("cube_large_sequence<long>", elapsed_time); + +// // SMALL OCTET SEQUENCES +// this->call_count_ = 0; +// this->error_count_ = 0; +// timer.start (); +// for (i = 0; i < this->loop_count_; i++) +// this->cube_octet_sequence (this->loop_count_, 16); +// timer.stop (); +// timer.elapsed_time (elapsed_time); +// this->print_stats ("cube_small_sequence<octet>", elapsed_time); + +// // LARGE OCTET SEQUENCES +// this->call_count_ = 0; +// this->error_count_ = 0; +// timer.start (); +// for (i = 0; i < this->loop_count_; i++) +// this->cube_octet_sequence (this->loop_count_, 4096); +// timer.stop (); +// timer.elapsed_time (elapsed_time); +// this->print_stats ("cube_large_sequence<octet>", elapsed_time); + + + // MIXIN + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + { + this->cube_short (i); + this->cube_octet (i); + this->cube_long (i); + } + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube mixin (short/octet/long)", elapsed_time); + + + return this->error_count_ == 0 ? 0 : 1; +} + +Cubit_Client::~Cubit_Client (void) +{ + // Free resources + // Close the ior files + if (this->cubit_factory_ior_file_) + ACE_OS::fclose (this->cubit_factory_ior_file_); + if (this->f_handle_ != ACE_INVALID_HANDLE) + ACE_OS::close (this->f_handle_); + + CORBA::release (this->cubit_); + + if (this->cubit_factory_key_ != 0) + ACE_OS::free (this->cubit_factory_key_); + if (this->cubit_key_ != 0) + ACE_OS::free (this->cubit_key_); +} + +int +Cubit_Client::init_naming_service (void) +{ + CORBA::Object_ptr dummy_object; + CosNaming::NamingContext_var nameserver; + CosNaming::Name name; + + try { + // Resolve initial reference to the nameserver + dummy_object = this->orb_-> resolve_initial_references("NameService"); + // Narrow the initial reference to the nameserver + nameserver = CosNaming::NamingContext::_narrow(dummy_object); + } catch (CORBA::BAD_PARAM) { + cout << "Bad parameter exception caught - narrow on the NameService" << endl; + exit(-1); + } catch (CORBA::SystemException) { + cout << "A general system exception was caught - resolve_initial_references" << endl; + exit(-1); + } catch (...) { + cout << "An exception of unknown type was caught - initializing the NameService" << endl; + exit(-1); + } + + // Resolve the server interface object which was bound under the name "cubit" + name.length(2); + + name[0].id = "cubit_S"; + name[0].kind = "ASE"; + name[1].id = "cubit"; + name[1].kind = "interface"; + + try { + dummy_object = nameserver -> resolve(name); + this->cubit_ = Cubit::_narrow(dummy_object); + } catch (CORBA::BAD_PARAM) { + cout << "Bad parameter exception caught - resolve or narrow on the cubit server object" << endl; + exit(-1); + } catch (...) { + cout << "An exception of unknown type was caught - resolve or narrow on the cubit server object" << endl; + exit(-1); + } + + cout << "cubit object resolved successfully\n"; + + return 0; +} + +int +Cubit_Client::init (int argc, char **argv) +{ + int argct; + char *argvt[1]; + int naming_result; + this->argc_ = argc; + this->argv_ = argv; + cout << "Starting the cubit client." << endl; + + try { + // Obtain an object reference to the ORB + argvt[0] = "-ORBase cubit_client"; + argct = 1; + this->orb_ = CORBA::ORB_init(argct, argvt, ORBIDENT); + } catch (CORBA::BAD_PARAM) { + cout << "Bad parameter exception caught - ORB_init" << endl; + exit(-1); + } catch (CORBA::INITIALIZE) { + cout << "Initialize exception caught - ORB_init" << endl; + exit(-1); + } catch (CORBA::INTERNAL) { + cout << "Internal exception caught - ORB_init" << endl; + exit(-1); + } catch (CORBA::UNKNOWN) { + cout << "Unknown exception caught - ORB_init" << endl; + exit(-1); + } catch(...) { + cout << "An exception of unknown type was caught - ORB_init" << endl; + exit(-1); + } + + try { + // Obtain an object reference to the BOA + argct = 0; + this->boa_ = this->orb_-> BOA_init(argct, argvt, BOAIDENT); + } catch (CORBA::UNKNOWN) { + cout << "Unknown exception caught - ORB_init" << endl; + exit(-1); + } catch (CORBA::SystemException) { + cout << "General system exception caught - BOA_init" << endl; + exit(-1); + } catch (...) { + cout << "An exception of unknown type was caught - BOA_init" << endl; + exit(-1); + } + naming_result = this->init_naming_service (); + if (naming_result < 0) + return naming_result; + + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) +template class ACE_Env_Value<unsigned long>; +template class ACE_Env_Value<unsigned short>; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +#pragma instantiate ACE_Env_Value<unsigned long> +#pragma instantiate ACE_Env_Value<unsigned short> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client_i.h b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client_i.h new file mode 100644 index 00000000000..6dbe4bb6362 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/client_i.h @@ -0,0 +1,140 @@ +// -*- c++ -*- +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// client.h +// +// = DESCRIPTION +// This class implements a simple "cube" CORBA client for the Cubit +// example using stubs generated by the TAO ORB IDL compiler. +// +// = AUTHORS +// Aniruddha Gokhale, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "ace/Get_Opt.h" +#include "ace/Profile_Timer.h" +#include "ace/Timeprobe.h" +#include "gpp_header.hh" +#include "naming.hh" +#include "cubit.hh" +#include "es.h" + +class Cubit_Client +{ + // = TITLE + // Defines a class that encapsulates behaviour of the Cubit client + // example. Provides a better understanding of the logic in an + // object oriented way. + // + // = DESCRIPTION + // This class declares an interface to run the example client for + // Cubit CORBA server. All the complexity for initializing the + // server is hidden in the class. Just the run() interface is needed. +public: + // = Constructor and destructor. + Cubit_Client (void); + ~Cubit_Client (void); + + int run (int testing_collocation = 0); + // Execute client example code. + + int init (int argc, char **argv); + // Initialize the client communication endpoint with server. + +private: + int init_naming_service (void); + // Function to initialize the naming service. + + int func (u_int i); + // Simple function that returns the substraction of 117 from the + // parameter. + + int read_ior (char *filename); + // Function to read the cubit factory ior from a file. + + int parse_args (void); + // Parses the arguments passed on the command line. + + void print_stats (const char *call_name, + ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time); + // Prints the time stats. + void cube_oneway (int i); + // Oneway operation test. + + void cube_void (int i); + // Twoway operation test. + + void cube_union (void); + // Exercise the union. Cube a union. + + void cube_struct (int i); +// // calculate the cube from a struct. + + void cube_long (int i); + // calculate the cube from a long. + + void cube_octet (int i); + // Cube an octet. + + void cube_short (int i); + // Cube a short. + + void cube_long_sequence (int i, int l); + // Cube a sequence <l> is the length of the sequence. + + void cube_octet_sequence (int i, int l); + // Cube a sequence of octets, <l> is the length of the sequence. + + int argc_; + // # of arguments on the command line. + + char **argv_; + // arguments from command line. + + char *cubit_factory_key_; + // Key of factory obj ref. + + char *cubit_key_; + // Key of the obj ref to be retrieved via the factory. + + u_int loop_count_; + // Number of times to do the cube operations. + + int shutdown_; + // Flag to tell server to shutdown. + + //Cubit_Factory_var factory_; + // factory pointer for cubit. + + Cubit_ptr cubit_; + // Cubit obj ref. + + CORBA::ORB_ptr orb_; + // Remember our orb. + + CORBA::BOA_ptr boa_; + // Basic object adapter + + u_int call_count_; + // # of calls made to functions. + + u_int error_count_; + // # of errors incurred in the lifetime of the application. + + FILE *cubit_factory_ior_file_; + // File from which to obtain the IOR. + + ACE_HANDLE f_handle_; + // File handle to read the IOR. + + int use_naming_service_; + // Flag to tell client not to use Namingservice to find the cubit + // Factory. +}; diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit.idl b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit.idl new file mode 100644 index 00000000000..cc14781d7da --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit.idl @@ -0,0 +1,96 @@ +/* -*- C++ -*- */ +// $Id$ + +interface Cubit + // = TITLE + // Defines an interface that encapsulates operations that cube + // numbers. + // + // = DESCRIPTION + // This interface encapsulates operations that cube + // octets, shorts, longs, structs and unions. +{ + oneway void cube_oneway (); + // test the basic latency of a nil oneway operation + + void cube_void (); + // Test the bassic latency of a nil operation + octet cube_octet (in octet o); + // cube an octet + + short cube_short (in short s); + // cube a short + + long cube_long (in long l); + // cube a long + + struct Many + { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + // Cube a struct + +// enum discrim +// { +// e_0th, +// e_1st, +// e_2nd, +// e_3rd +// }; +// // Enumeration of the different elements in a union. + +// union oneof switch (discrim) +// { +// // this is an easy union to interpret; no padding +// // is needed between discriminant and value. +// case e_0th: +// octet o; +// case e_1st: +// short s; +// case e_2nd: +// long l; +// case e_3rd: +// Many cm; + +// // default: +// // Many cm; +// }; +// // Union of different types. + +// oneof cube_union (in oneof values); +// // cube a union. + + typedef sequence<long> long_seq; + + void cube_long_sequence (in long_seq input, + out long_seq output); + // Cube several longs. + + + typedef sequence<octet> octet_seq; + void cube_octet_sequence (in octet_seq input, out octet_seq output); + // Cube an octet sequence. + + oneway void shutdown (); + // shutdown the application. +}; + +// interface Cubit_Shutdown +// { +// // = TITLE +// // We need this class to shutdown the server +// // when testing collocation. +// oneway void shutdown (); +// // shutdown the program. +// }; + +// interface Cubit_Factory +// // = TITLE +// // Creates Cubit objects. +// { +// Cubit make_cubit (); +// }; diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit_impl.cc b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit_impl.cc new file mode 100644 index 00000000000..24e38720f87 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit_impl.cc @@ -0,0 +1,163 @@ +// $Id$ +#include "cubit_impl.hh" + +// This file is a skeleton of the implementation of the _impl class. + + +//============== Cubit implementation ============== +Cubit_impl::Cubit_impl() : _sk_Cubit(0) { +// Do not change the signature for this constructor + +} + +Cubit_impl::~Cubit_impl() { + +} + +void Cubit_impl::cube_oneway( + ) { +} + + +void Cubit_impl::cube_void( + ) { +} + +CORBA::Octet Cubit_impl::cube_octet( + CORBA::Octet o + ) { + return o * o * o; +} + + +CORBA::Short Cubit_impl::cube_short( + CORBA::Short s + ) { + return s * s * s; +} + + +CORBA::Long Cubit_impl::cube_long( + CORBA::Long l + ) { + return l * l * l; +} + + +Cubit::Many Cubit_impl::cube_struct( + const Cubit::Many& values + ) { + Cubit::Many temp; + + temp.o = values.o * values.o * values.o; + temp.s = values.s * values.s * values.s; + temp.l = values.l * values.l * values.l; + + return temp; + +} + +// Cubit::oneof Cubit_impl::cube_union( +// const Cubit::oneof& values +// ) { +// Cubit::oneof temp; + +// ACE_UNUSED_ARG (env); +// switch (values._d ()) +// { +// case Cubit::e_0th: +// temp.o (values.o () * values.o () * values.o ()); +// break; +// case Cubit::e_1st: +// temp.s (values.s () * values.s () * values.s ()); +// break; +// case Cubit::e_2nd: +// temp.l (values.l () * values.l () * values.l ()); +// break; +// case Cubit::e_3rd: +// default: +// temp._d (values._d ()); // set the discriminant +// // use the read/write accessor +// temp.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o; +// temp.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s; +// temp.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l; + +// } +// return temp; +// } + +void Cubit_impl::cube_long_sequence( + const Cubit::long_seq& input, + Cubit::long_seq*& output + ) { + + if (output == 0) + output = new Cubit::long_seq (input.length ()); + + output->length (input.length ()); + CORBA::ULong i = 0; + CORBA::Long x = input[0]; + output[i] = x * x * x; + +} + + +void Cubit_impl::cube_octet_sequence( + const Cubit::octet_seq& input, + Cubit::octet_seq*& output + ) { + if (output == 0) + { + output = new Cubit::octet_seq (input.length ()); + } + // We don't want to cube all the elements on the sequence because + // that will take too long and will affect the performance. Further, + // we want to show that octet sequences have constant marshalling + // time, but making a copy of each element will hide that. + CORBA::ULong i = 0; + CORBA::Octet x = input[0]; + output[i] = x * x * x; + +} + + +void Cubit_impl::shutdown( + ) { + +} + + + +// //============== Cubit_Shutdown implementation ============== +// Cubit_Shutdown_impl::Cubit_Shutdown_impl() : _sk_Cubit_Shutdown(0) { +// // Do not change the signature for this constructor + +// } + +// Cubit_Shutdown_impl::~Cubit_Shutdown_impl() { + +// } + +// void Cubit_Shutdown_impl::shutdown( +// ) { + +// } + + + +// //============== Cubit_Factory implementation ============== +// Cubit_Factory_impl::Cubit_Factory_impl() : _sk_Cubit_Factory(0) { +// // Do not change the signature for this constructor + +// } + +// Cubit_Factory_impl::~Cubit_Factory_impl() { + +// } + +// Cubit_ptr Cubit_Factory_impl::make_cubit( +// ) { +// return this->my_cubit_; +// } + + diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit_impl.hh b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit_impl.hh new file mode 100644 index 00000000000..8cb5312cc1f --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/cubit_impl.hh @@ -0,0 +1,48 @@ +#ifndef __cubit__impl_hh_def +#define __cubit__impl_hh_def + +#include "cubit.hh" + +// This file is a skeleton for the _impl class. + + +//============== Cubit_impl ============== +class Cubit_impl; +typedef Cubit_impl * Cubit_impl_ptr; + +class Cubit_impl : public virtual _sk_Cubit { +public: + +Cubit_impl(); +~Cubit_impl(); + +void cube_oneway( + ); +void cube_void( + ); +CORBA::Octet cube_octet( + CORBA::Octet o + ); +CORBA::Short cube_short( + CORBA::Short s + ); +CORBA::Long cube_long( + CORBA::Long l + ); +Cubit::Many cube_struct( + const Cubit::Many& values + ); +void cube_long_sequence( + const Cubit::long_seq& input, + Cubit::long_seq*& output + ); +void cube_octet_sequence( + const Cubit::octet_seq& input, + Cubit::octet_seq*& output + ); +void shutdown( + ); +private: +}; // End of class Cubit_impl + +#endif diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/initref.cfg b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/initref.cfg new file mode 100644 index 00000000000..d08f36322c2 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/initref.cfg @@ -0,0 +1,18 @@ + #***************************************************************/ + #* initref.cfg */ + #***************************************************************/ + # This file contains information for resolving initial references. + # An entry for the Naming Service is required; others are optional. + # + # The ORB will use this file to locate the NameService which is a server + # which supports the CosNaming_NamingContext interface. The current working + # directory will be checked for the existence of this file. If it is not + # found it will be looked for in your $HOME directory. This will allow + # concurrent users to execute a unique NameService, thereby allowing for + # concurrent development on the same system. + # + #***************************************************************/ + # + # Identifier Host Name ASE Name Port Number Interface Name + + NameService polka NAMING_S 10000 CosNaming_NamingContext diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server.cpp b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server.cpp new file mode 100644 index 00000000000..e82e1d84cc9 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server.cpp @@ -0,0 +1,21 @@ +// $Id$ + +#include "server_i.h" + +ACE_RCSID(IDL_Cubit, server, "$Id$") + +int +main (int argc, char *argv[]) +{ + Cubit_Server cubit_server; + + ACE_DEBUG ((LM_DEBUG, + "\n\tIDL_Cubit:SERVER\n\n")); + if (cubit_server.init (argc, argv) == -1) + return 1; + else + { + cubit_server.run (); + } + return 0; +} diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server_i.cpp b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server_i.cpp new file mode 100644 index 00000000000..13208fa19c8 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server_i.cpp @@ -0,0 +1,180 @@ +// $Id$ + +#include "server_i.h" + +ACE_RCSID(IDL_Cubit, server_i, "$Id$") + +Cubit_Server::Cubit_Server (void) + : num_of_objs_ (1), + use_naming_service_ (1), + ior_output_file_ (0) +{ +} + +int +Cubit_Server::parse_args (void) +{ + ACE_Get_Opt get_opts (argc_, argv_, "n:o:s"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'n': // number of cubit objects we export + this->num_of_objs_ = ACE_OS::atoi (get_opts.optarg); + break; + case 'o': // output the IOR to a file. + this->ior_output_file_ = ACE_OS::fopen (get_opts.optarg, "w"); + if (this->ior_output_file_ == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to open %s for writing: %p\n", + get_opts.optarg), -1); + break; + case 's': // Don't use the TAO Naming Service. + this->use_naming_service_=0; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-n num of cubit objects]" + " [-o ior_output_file]" + " [-s]" + "\n", + argv_ [0]), + 1); + } + + // Indicates successful parsing of command line. + return 0; +} + +int +Cubit_Server::init (int argc, + char** argv) +{ + int argct; + char *argvt[1]; + + this->argc_ = argc; + this->argv_ = argv; + + if (this->parse_args () == -1) + return -1; + + try { + // Obtain an object reference to the ORB + argvt[0] = "-ORBase cubit_S"; + argct = 1; + this->orb_ = CORBA::ORB_init(argct, argvt, ORBIDENT); + } catch (CORBA::BAD_PARAM) { + cout << "Bad parameter exception caught - ORB_init" << endl; + return -1; + } catch (CORBA::INITIALIZE) { + cout << "Initialize exception caught - ORB_init" << endl; + return -1; + } catch (CORBA::INTERNAL) { + cout << "Internal exception caught - ORB_init" << endl; + return -1; + } catch (CORBA::UNKNOWN) { + cout << "Unknown exception caught - ORB_init" << endl; + return -1; + } catch(...) { + cout << "An exception of unknown type was caught - ORB_init" << endl; + return -1; + } + + + try { + // Obtain an object reference to the BOA + argct = 0; + this->boa_ = this->orb_->BOA_init(argct, argvt, BOAIDENT); + } catch (CORBA::UNKNOWN) { + cout << "Unknown exception caught - ORB_init" << endl; + return -1; + } catch (CORBA::SystemException) { + cout << "General system exception caught - BOA_init" << endl; + return -1; + } catch (...) { + cout << "An exception of unknown type was caught - BOA_init" << endl; + return -1; + } + + ACE_NEW_RETURN (this->cubit_, + Cubit_impl, + -1); + + if (this->use_naming_service_) + return this->init_naming_service (); + + return 0; +} + +// Initialisation of Naming Service and register IDL_Cubit Context and +// cubit_factory object. + +int +Cubit_Server::init_naming_service (void) +{ + CosNaming::Name name; + CosNaming::NamingContext_ptr cubit_S_context; + CORBA::Object_ptr dummy_object; + try { + // Resolve initial references to the nameserver + dummy_object = this->orb_->resolve_initial_references("NameService"); + this->nameserver_ = CosNaming::NamingContext::_narrow(dummy_object); + } catch (CORBA::BAD_PARAM) { + cout << "Bad parameter exception caught - narrow on the NameService" << endl; + return -1; + } catch (CORBA::SystemException) { + cout << "A general system exception was caught - resolve_initial_references" << endl; + return -1; + } catch (...) { + cout << "An exception of unknown type was caught - initializing the NameService" << endl; + return -1; + } + + try { + // Bind the new context of the server name to the nameserver + name.length(1); + name[0].id = "cubit_S"; + name[0].kind = "ASE"; + cubit_S_context = this->nameserver_ -> bind_new_context(name); + } catch(...) { + cout << "Naming service exception caught - bind of cubit_S context" << endl; + return -1; + } + + try { + // Bind the server interface object to the nameserver, so the client + // can resolve this server interface object + name[0].id = "cubit"; + name[0].kind = "interface"; + cubit_S_context -> bind(name, this->cubit_); + } catch (...) { + cout << "Naming service exception caught - bind of name to cubit object" << endl; + return -1; + } + + + return 0; +} + +int +Cubit_Server::run (void) +{ + + try { + // Process client requests forever + while (1) + select_wait(-1.0); + } catch (...) { + cout << "Exception of unknown type caught when servicing requests" << endl; + return -1; + } + return 0; +} + +Cubit_Server::~Cubit_Server (void) +{ +} diff --git a/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server_i.h b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server_i.h new file mode 100644 index 00000000000..310338e8432 --- /dev/null +++ b/TAO/performance-tests/Cubit/Hardpack/IDL_Cubit/server_i.h @@ -0,0 +1,107 @@ +// -*- c++ -*- +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// server_i.h +// +// = DESCRIPTION +// This class implements a simple "cube" CORBA server for the Cubit +// example using skeletons generated by the TAO ORB IDL compiler. +// +// = AUTHORS +// Nagarajan Surendran (naga@cs.wustl.edu) +// +// ============================================================================ + +#if !defined (_C_SERVER_H) +#define _C_SERVER_H + +#include "ace/Get_Opt.h" +#include "ace/Log_Msg.h" +#include "gpp_header.hh" +#include "naming.hh" +#include "cubit_impl.hh" + +class Cubit_Server +{ + // = TITLE + // Defines a Cubit Server class that implements the functionality + // of a server process as an object. + // + // = DESCRIPTION + // The interface is quite simple. A server program has to call + // init to initialize the cubit_server's state and then call run + // to run the orb. +public: + // = Initialization and termination methods. + Cubit_Server (void); + // Default constructor + + ~Cubit_Server (void); + // Destructor + + int init (int argc, + char **argv); + // Initialize the Cubit_Server state - parsing arguments and ... + + int run (void); + // Run the orb + +private: + int parse_args (void); + // Parses the commandline arguments. + + int init_naming_service (void); + // Initialises the name server and registers cubit factory with the + // name server. + + int num_of_objs_; + // Number of cubit objects we export. + + int use_naming_service_; + //Flag to tell server not to use the TAO Naming Service to register + //the cubit factory. + + FILE* ior_output_file_; + // File to output the cubit factory IOR. + + // Cubit_Factory_i factory_impl_; + // Implementation object of the cubit factory. + + //Cubit_Factory_var factory; + // Factory_var to register with NamingService. + + // Cubit_Shutdown_i shutdown_impl_; + // Implementation object of shutdown object. + + // Cubit_Shutdown_var shutdown_; + + CosNaming::NamingContext_var cubit_context_; + // Naming context for the cubit_factory. + + CosNaming::NamingContext_var nameserver_; + // Naming context for the Naming Service. + + Cubit_impl_ptr cubit_; + // pointer to the cubit object + + int argc_; + // Number of commandline arguments. + + char **argv_; + // commandline arguments. + + CORBA::ORB_ptr orb_; + // pointer to the ORB + + CORBA::BOA_ptr boa_; + // pointer to the BOA + +}; + +#endif /* _C_SERVER_H */ diff --git a/TAO/performance-tests/Cubit/Makefile b/TAO/performance-tests/Cubit/Makefile new file mode 100644 index 00000000000..db182c11161 --- /dev/null +++ b/TAO/performance-tests/Cubit/Makefile @@ -0,0 +1,28 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +# Makefile for the Cubit test (for several ORBs) +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +DIRS = TAO + +# These are disabled by default... +# Orbix \ +# VisiBroker + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nolocal.GNU + diff --git a/TAO/performance-tests/Cubit/Orbix/Makefile b/TAO/performance-tests/Cubit/Orbix/Makefile new file mode 100644 index 00000000000..4dad4109daa --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/Makefile @@ -0,0 +1,28 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the Gateway application +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +INFO = README + +DIRS = base_server \ + client \ + tpr \ + tpool \ + tps + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nolocal.GNU + diff --git a/TAO/performance-tests/Cubit/Orbix/base_server/Makefile b/TAO/performance-tests/Cubit/Orbix/base_server/Makefile new file mode 100644 index 00000000000..534ba4a20bb --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/base_server/Makefile @@ -0,0 +1,73 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the ACE_MT_CORBA_Handler tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +SRC = cubitS.cpp cubit_impl.cpp server.cpp + +SVR_OBJS = cubitS.o cubit_impl.o server.o + +LDLIBS = -lorbixmt + +VLDLIBS = $(LDLIBS:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- +exceptions = 1 + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU +include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#---------------------------------------------------------------------------- +# Orbix related macros and target settings. +#---------------------------------------------------------------------------- + + +ORBIX_BINDIR = $(ORBIX_ROOT)/bin +ORBIX_LIBDIR = $(ORBIX_ROOT)/lib +ORBIX_INCDIR = $(ORBIX_ROOT)/inc + +# Remove -DCubit_USE_BOA from below to use the TIE approach + +CPPFLAGS += -DEXCEPTIONS -I$(ORBIX_INCDIR) -DWANT_ORBIX_FDS -DCubit_USE_BOA +LDFLAGS += -L$(ORBIX_LIBDIR) -R $(ORBIX_LIBDIR) -L$(ACE)/ace + +IDLFLAGS = -s S.cpp -c C.cpp -B + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +all: server + +server: $(addprefix $(VDIR),$(SVR_OBJS)) + $(LINK.cc) -o server $(addprefix $(VDIR),$(SVR_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITSRV) $(VLDLIBS) $(POSTLINK) + +realclean: clean + -/bin/rm -rf server cubitC.* cubitS.* cubit.hh +#---------------------------------------------------------------------------- +# Dependencies +#---------------------------------------------------------------------------- +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubitS.o .obj/cubitS.so .shobj/cubitS.o .shobj/cubitS.so: cubitS.cpp cubit.hh cubitC.cpp +.obj/cubit_impl.o .obj/cubit_impl.so .shobj/cubit_impl.o .shobj/cubit_impl.so: cubit_impl.cpp cubit_impl.h cubit.hh +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h cubit_impl.h \ + cubit.hh + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/Orbix/base_server/cubit.idl b/TAO/performance-tests/Cubit/Orbix/base_server/cubit.idl new file mode 100644 index 00000000000..d4f1610e2a8 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/base_server/cubit.idl @@ -0,0 +1,42 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. + +#pragma prefix "Eng.SUN.COM" +#pragma version Cubit 1.1 + +interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); +}; diff --git a/TAO/performance-tests/Cubit/Orbix/base_server/cubit_impl.cpp b/TAO/performance-tests/Cubit/Orbix/base_server/cubit_impl.cpp new file mode 100644 index 00000000000..4661cba6809 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/base_server/cubit_impl.cpp @@ -0,0 +1,50 @@ +// $Id$ + +#include "cubit_impl.h" + +ACE_RCSID(base_server, cubit_impl, "$Id$") + +CORBA::Octet Cubit_Impl:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Octet) (o * o * o); +} + +CORBA::Short Cubit_Impl:: cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Short) (s * s * s); +} + +CORBA::Long Cubit_Impl:: cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Long) (l * l * l); +} + +Cubit::Many Cubit_Impl:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + Cubit::Many out_values; + out_values.o = values.o * values.o * values.o; + out_values.s = values.s * values.s * values.s; + out_values.l = values.l * values.l * values.l; + return out_values; +} + +Cubit::oneof Cubit_Impl:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + Cubit::oneof out_values; + switch (values._d ()) { + case Cubit::e_0th: + out_values.o (values.o () * values.o () * values.o ()); + break; + case Cubit::e_1st: + out_values.s (values.s () * values.s () * values.s ()); + break; + case Cubit::e_2nd: + out_values.l (values.l () * values.l () * values.l ()); + break; + case Cubit::e_3rd: + default: + out_values.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o ; + out_values.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s ; + out_values.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l ; + break; + } + return out_values; +} + +void Cubit_Impl:: please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException) { +} diff --git a/TAO/performance-tests/Cubit/Orbix/base_server/cubit_impl.h b/TAO/performance-tests/Cubit/Orbix/base_server/cubit_impl.h new file mode 100644 index 00000000000..5fb494ad4cf --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/base_server/cubit_impl.h @@ -0,0 +1,29 @@ +// $Id$ + + +#ifndef cubit_ih +#define cubit_ih + +#include "cubit.hh" + + +#ifdef Cubit_USE_BOA +class Cubit_Impl : public virtual CubitBOAImpl { +#else +class Cubit_Impl { +#endif /* Cubit_USE_BOA */ + +public: + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); +}; + +#ifndef Cubit_USE_BOA +DEF_TIE_Cubit (Cubit_Impl) +#endif /* Cubit_USE_BOA */ + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/base_server/server.cpp b/TAO/performance-tests/Cubit/Orbix/base_server/server.cpp new file mode 100644 index 00000000000..21cc6adf755 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/base_server/server.cpp @@ -0,0 +1,45 @@ +// $Id$ + +//************************************************************************** +// +// NAME : tpr_server.cpp +// DESCRIPTION: +// +// Server mainline +// +//**************************************************************************** +#define IT_EX_MACROS + +#include "ace/streams.h" +#include "cubit_impl.h" // server header file + +ACE_RCSID(base_server, server, "$Id$") + +int +main (int , char**) +{ + +#ifdef Cubit_USE_BOA + Cubit_var cb = new Cubit_Impl; + cout << "Using BOA approach" << endl; +#else + Cubit_var cb = new TIE_Cubit (Cubit_Impl) (new Cubit_Impl); + cout << "Using TIE approach" << endl; +#endif /* Cubit_USE_BOA */ + + // + // Go get some work to do.... + // + IT_TRY { + CORBA::Orbix.impl_is_ready("Cubit", IT_X); + } + IT_CATCHANY { + cout << IT_X << endl; + } + IT_ENDTRY; + + cout << "Cubit server is exiting." << endl; + + + return 0; +} diff --git a/TAO/performance-tests/Cubit/Orbix/client/Makefile b/TAO/performance-tests/Cubit/Orbix/client/Makefile new file mode 100644 index 00000000000..f6de04f712b --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/client/Makefile @@ -0,0 +1,89 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the ACE_MT_CORBA_Handler tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +SRC = cubitC.cpp client.cpp + +CLT_OBJS = cubitC.o client.o + +LDLIBS = + +VLDLIBS = $(LDLIBS:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU +include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#---------------------------------------------------------------------------- +# Orbix related macros and target settings. +#---------------------------------------------------------------------------- + + +ORBIX_BINDIR = $(ORBIX_ROOT)/bin +ORBIX_LIBDIR = $(ORBIX_ROOT)/corba2/lib +ORBIX_INCDIR = $(ORBIX_ROOT)/corba2/include + +CPPFLAGS += -DEXCEPTIONS -I$(ORBIX_INCDIR) -DWANT_ORBIX_FDS +LDFLAGS += -L$(ORBIX_LIBDIR) -R $(ORBIX_LIBDIR) -L$(ACE)/ace + +IDLFLAGS = -s S.cpp -c C.cpp -B + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +all: client + +client: $(addprefix $(VDIR),$(CLT_OBJS)) + $(LINK.cc) -o client $(addprefix $(VDIR),$(CLT_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITCLT) $(VLDLIBS) $(POSTLINK) + + +#---------------------------------------------------------------------------- +# Dependencies +#---------------------------------------------------------------------------- +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubitC.o .shobj/cubitC.so: cubitC.cpp cubit.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i +.obj/client.o .shobj/client.so: client.cpp $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i cubit.h + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/Orbix/client/client.cpp b/TAO/performance-tests/Cubit/Orbix/client/client.cpp new file mode 100644 index 00000000000..163aaf5b8f7 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/client/client.cpp @@ -0,0 +1,299 @@ +// $Id$ + +//************************************************************************** +// +// NAME : client.C +// DESCRIPTION: +// +// Client for the Cubit example +// +//**************************************************************************** + +#include "ace/OS.h" +#include "ace/Get_Opt.h" +#include "cubit.h" + +ACE_RCSID(client, client, "$Id$") + +int LOOP_COUNT; +char SERVER_HOST [1024]; + +inline int func (unsigned i) { return i - 117; } +void run_tests (Cubit_var, int); + +// = TITLE +// Parses the command line arguments and returns an error status +// +// = DESCRIPTION +// This method parses the command line arguments +int parse_args(int argc, char *argv[]) +{ + ACE_OS::strcpy (SERVER_HOST, "localhost"); + ACE_Get_Opt opts (argc, argv, "dh:n:O:x"); + int c; + + while ((c = opts ()) != -1) + switch (c) { + case 'h': + ACE_OS::strcpy (SERVER_HOST, opts.optarg); + continue; + case 'd': // debug flag + continue; + + case 'n': // loop count + LOOP_COUNT = (unsigned) ACE_OS::atoi (opts.optarg); + continue; + + case 'O': // stringified objref + continue; + + case 'x': + continue; + + case '?': + default: + ACE_OS::fprintf (stderr, "usage: %s" + " [-d]" + " [-n loopcount]" + " [-h SERVER_HOST]" + " [-x]" + "\n", argv [0] + ); + return 1; + } + + return 0; // Indicates successful parsing of command line +} + + +// +// Mainline +// +int +main (int argc, char *argv[]) +{ + if (parse_args (argc, argv) != 0) + return -1; + + Cubit_var cb; + // cout << "attempting to contact server at host " << SERVER_HOST << '\n' ; + + // + // Initialise client's binding to an + // arbitrary cubit server (at some host) + // + TRY { + cb = Cubit::_bind ("", SERVER_HOST, IT_X); + } + CATCHANY { + cerr << "Binding failed: " << IT_X; + } + ENDTRY; + + run_tests (cb, LOOP_COUNT); + return 0; +} + + +void +run_tests (Cubit_var cb, int loop_count) +{ + // + // Make the calls in a loop. + // + unsigned i; + unsigned call_count, error_count; + + ACE_Time_Value before, after; + + + // + // Cube an octet. + // + + call_count = 0; + error_count = 0; + before = ACE_OS::gettimeofday(); + + for (i = 0; i < loop_count; i++) + { + + call_count++; + + CORBA::Octet arg_octet = func (i), ret_octet; + + TRY { + ret_octet = cb->cube_octet (arg_octet); + } + CATCHANY { + cerr << "Call failed: " << IT_X; + error_count++; + } + ENDTRY; + arg_octet = arg_octet * arg_octet * arg_octet; + if (arg_octet != ret_octet) { + ACE_OS::printf ("** cube_octet(%d) (--> %d)\n", arg_octet , ret_octet); + error_count++; + } + } + + // + // Cube a short. + // + call_count = 0; + error_count = 0; + before = ACE_OS::gettimeofday(); + + for (i = 0; i < loop_count; i++) + { + call_count++; + + CORBA::Short arg_short = func (i), ret_short; + + TRY { + ret_short = cb->cube_short (arg_short); + } + CATCHANY { + cerr << "Call failed: " << IT_X; + error_count++; + } + ENDTRY; + arg_short = arg_short * arg_short * arg_short; + if (arg_short != ret_short) { + ACE_OS::printf ("** cube_short(%d) (--> %d)\n", arg_short , ret_short); + error_count++; + } + + } + after = ACE_OS::gettimeofday(); + + if (call_count > 0) + { + if (error_count == 0) + { + ACE_Time_Value diff = after - before; + unsigned long us = diff.sec() * 1000 * 1000 + diff.usec(); + + us /= call_count; + + if (us > 0) + ACE_OS::printf ("cube average call ACE_OS::time\t= %ld.%.03ldms, \t" + "%ld calls/second\n", + us / 1000, us % 1000, + 1000000L / us); + } + + ACE_OS::printf ("%d calls, %d errors\n", call_count, error_count); + } + + // + // Cube a long. + // + + call_count = 0; + error_count = 0; + before = ACE_OS::gettimeofday(); + + for (i = 0; i < loop_count; i++) + { + + call_count++; + + CORBA::Long arg_long = func (i), ret_long; + + TRY { + ret_long = cb->cube_long (arg_long); + } + CATCHANY { + cerr << "Call failed: " << IT_X; + } + ENDTRY; + arg_long = arg_long * arg_long * arg_long; + if (arg_long != ret_long) { + ACE_OS::printf ("** cube_long(%d) (--> %d)\n", arg_long , ret_long); + error_count++; + } + + } + after = ACE_OS::gettimeofday(); + + if (call_count > 0) + { + if (error_count == 0) + { + ACE_Time_Value diff = after - before; + unsigned long us = diff.sec() * 1000 * 1000 + diff.usec(); + + us /= call_count; + + if (us > 0) + ACE_OS::printf ("cube average call ACE_OS::time\t= %ld.%.03ldms, \t" + "%ld calls/second\n", + us / 1000, us % 1000, + 1000000L / us); + } + + ACE_OS::printf ("%d calls, %d errors\n", call_count, error_count); + } + + // + // Cube a "struct" ... + // + Cubit::Many arg_struct, ret_struct; + + call_count = 0; + error_count = 0; + before = ACE_OS::gettimeofday(); + + for (i = 0; i < loop_count; i++) + { + + call_count++; + + arg_struct.l = func (i); + arg_struct.s = func (i); + arg_struct.o = func (i); + + TRY { + ret_struct = cb->cube_struct (arg_struct); + } + CATCHANY { + cerr << "Call failed: " << IT_X; + error_count++; + } + ENDTRY; + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l ; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s ; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o ; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o ) + { + cerr << "** cube_struct ERROR\n"; + error_count++; + } + } + + after = ACE_OS::gettimeofday(); + + if (call_count > 0) + { + if (error_count == 0) + { + ACE_Time_Value diff = after - before; + unsigned long us = diff.sec() * 1000 * 1000 + diff.usec(); + + us /= call_count; + + if (us > 0) + ACE_OS::printf ("cube average call ACE_OS::time\t= %ld.%.03ldms, \t" + "%ld calls/second\n", + us / 1000, us % 1000, + 1000000L / us); + } + + ACE_OS::printf ("%d calls, %d errors\n", call_count, error_count); + } + +} diff --git a/TAO/performance-tests/Cubit/Orbix/client/cubit.h b/TAO/performance-tests/Cubit/Orbix/client/cubit.h new file mode 100644 index 00000000000..1fd0a2d3c7d --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/client/cubit.h @@ -0,0 +1,729 @@ +// $Id$ + + +#ifndef cubit_hh +#define cubit_hh + +#include "ace/OS.h" +#include <CORBA.h> + + +#ifndef _Cubit_defined +#define _Cubit_defined +class Cubit_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch () {} + + Cubit_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit; + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + + +#ifndef CubitForwH +#define CubitForwH +CORBA::ObjectRef Cubit_getBase (void *); +void Cubit_release (Cubit *, CORBA::Environment &IT_env); +void Cubit_release (Cubit_ptr); +Cubit* Cubit_duplicate (Cubit_ptr, CORBA::Environment &IT_env); +Cubit* Cubit_duplicate (Cubit_ptr ); +Cubit_ptr Cubit_nil (CORBA::Environment &IT_env); +Cubit_ptr Cubit_nil (); +#endif +#define Cubit_IMPL "Cubit" + + +class Cubit; + +typedef Cubit CubitProxy; +#define Cubit_IR "Cubit$v1.1" +#define Cubit_IMPL "Cubit" + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + +class Cubit: public virtual CORBA::Object { +public: + Cubit (char *IT_OR); + Cubit (ObjectReference *IT_OR); + Cubit () : CORBA::Object (1) {} +protected: + Cubit_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_ptr _duplicate( + Cubit_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _bind (CORBA::Environment &IT_env); + static Cubit* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_ptr) CORBA::OBJECT_NIL;} + +#ifndef Cubit_Many_defined +#define Cubit_Many_defined + +struct Many { + CORBA::Octet o; + CORBA::Long l; + CORBA::Short s; + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + Many(const Many &); + Many(); + ~Many(); + Many& operator= (const Many&); +}; + +#ifndef Cubit_ManyVarH +#define Cubit_ManyVarH + +#ifndef Cubit_ManyvPtr +#define Cubit_ManyvPtr +typedef Many* Many_vPtr; +typedef const Many* Many_cvPtr; +#endif + +class Many_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Many_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + Many_var (const Many_var &IT_s) { + (void) copyHelper (IT_s); + } + + Many_var () { + _ptr = new Many; +; + } + + Many_var (Many *IT_p) { + _ptr = IT_p; + } + + Many_var &operator= (Many *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + Many_var &operator= (const Many_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~Many_var () { + delete _ptr; + } + + Many* operator-> () { + return _ptr; + } + + operator Many_cvPtr () const { return _ptr;} + operator Many_vPtr& () { return _ptr;} + operator Many& () const { return * _ptr;} + + protected: + Many *_ptr; + private: + Many_var &operator= (const CORBA::_var &IT_s); + Many_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + +enum discrim {e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th, IT__ENUM_Cubit_discrim=CORBA_ULONG_MAX}; + +#ifndef Cubit_oneof_defined +#define Cubit_oneof_defined + +struct oneof { + private: + + discrim __d; + union { + CORBA::Octet _o_; + CORBA::Short _s_; + CORBA::Long _l_; + Many * _cm_; + }; + + public: + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + + private: + + unsigned char isSet; + + public: + + discrim _d () const { return __d; } + + CORBA::Octet o () const { + return _o_; + } + + void o (CORBA::Octet IT_member) { + if (isSet && (__d != Cubit::e_0th)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_0th; + isSet = 1; + _o_ = IT_member; + } + + CORBA::Short s () const { + return _s_; + } + + void s (CORBA::Short IT_member) { + if (isSet && (__d != Cubit::e_1st)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_1st; + isSet = 1; + _s_ = IT_member; + } + + CORBA::Long l () const { + return _l_; + } + + void l (CORBA::Long IT_member) { + if (isSet && (__d != Cubit::e_2nd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_2nd; + isSet = 1; + _l_ = IT_member; + } + + Many& cm () { + return (*_cm_); + } + + const Many& cm () const { + return (*_cm_); + } + + void cm (const Many& IT_member) { + if (isSet && (__d != Cubit::e_3rd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_3rd; + + if (!isSet) { + _cm_ = new Many; + isSet = 1; + } + *(_cm_) = IT_member; + } + + + oneof(); + oneof(const oneof &); + ~oneof(); + oneof& operator= (const oneof&); +}; + +#ifndef Cubit_oneofVarH +#define Cubit_oneofVarH + +#ifndef Cubit_oneofvPtr +#define Cubit_oneofvPtr +typedef oneof* oneof_vPtr; +typedef const oneof* oneof_cvPtr; +#endif + +class oneof_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const oneof_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + oneof_var (const oneof_var &IT_s) { + (void) copyHelper (IT_s); + } + + oneof_var () { + _ptr = NULL; + } + + oneof_var (oneof *IT_p) { + _ptr = IT_p; + } + + oneof_var &operator= (oneof *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + oneof_var &operator= (const oneof_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~oneof_var () { + delete _ptr; + } + + oneof* operator-> () { + return _ptr; + } + + operator oneof_cvPtr () const { return _ptr;} + operator oneof_vPtr& () { return _ptr;} + operator oneof& () const { return * _ptr;} + + protected: + oneof *_ptr; + private: + oneof_var &operator= (const CORBA::_var &IT_s); + oneof_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef CubitVarH +#define CubitVarH + +#ifndef CubitvPtr +#define CubitvPtr +typedef Cubit* Cubit_vPtr; +typedef const Cubit* Cubit_cvPtr; +#endif + +class Cubit_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_var &IT_s) { + { + _ptr = Cubit_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_var (const Cubit_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_var () { + _ptr = Cubit_nil (); + } + + Cubit_var (Cubit *IT_p) { + _ptr = IT_p; + } + + Cubit_var &operator= (Cubit *IT_p) { + Cubit_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_var &operator= (const Cubit_var &IT_s) { + Cubit_release (_ptr); + _ptr = Cubit_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_var () { + Cubit_release (_ptr); + } + + Cubit* operator-> () { + return _ptr; + } + + operator Cubit_cvPtr () const { return _ptr;} + operator Cubit_vPtr& () { return _ptr;} + + protected: + Cubit *_ptr; + private: + Cubit_var &operator= (const CORBA::_var &IT_s); + Cubit_var (const CORBA::_var &IT_s); + Cubit_var &operator= (const CORBA::_mgr &IT_s); + Cubit_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_var (const CORBA::_mgr &IT_s); + Cubit_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef CubitMgrH +#define CubitMgrH + +class Cubit_mgr : public CORBA::_mgr +{ + public: + + Cubit_mgr () { + _ptr = Cubit_nil (); + _release = 1; + } + + Cubit_mgr (const Cubit_mgr &IT_s) { + _ptr = Cubit_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_mgr &operator= (Cubit *IT_p) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (const Cubit_mgr &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (Cubit_var &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_mgr () { + if (_release) + Cubit_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit* () const { + return (Cubit*) _ptr; + } + + Cubit_ptr operator-> () const { + return _ptr; + } + + Cubit *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_mgr Cubit_mgr_IT_const; +#endif + +#ifndef CubitSeqElemH +#define CubitSeqElemH + +class Cubit_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_SeqElem &operator= (Cubit_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_SeqElem &operator= (const Cubit_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = Cubit_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_ptr () const { + return _ptr ? (Cubit_ptr) (*_ptr) : Cubit_nil(); + } + + Cubit_ptr operator->() const { return *_ptr;} + + protected: + Cubit_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit(X) Cubit##X + +#define DEF_TIE_Cubit(X) \ + class Cubit##X : public virtual Cubit { \ + X* m_obj; \ + public: \ + \ + \ + Cubit##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit(), m_obj(objp) { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,m,l,Cubit_IR,m_obj); \ + } \ + Cubit##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit() { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,IT_m,Cubit_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + + + + +class CubitProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + CubitProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern CubitProxyFactoryClass CubitProxyFactory; + +class CubitBOAImpl : public virtual Cubit { +public: + CubitBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_IR)) + m_pptr = new Cubit_dispatch ( (Cubit*)this, + (CORBA::Object*)this, m, l, Cubit_IR, this); +} + + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/client/cubit.idl b/TAO/performance-tests/Cubit/Orbix/client/cubit.idl new file mode 100644 index 00000000000..d4f1610e2a8 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/client/cubit.idl @@ -0,0 +1,42 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. + +#pragma prefix "Eng.SUN.COM" +#pragma version Cubit 1.1 + +interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); +}; diff --git a/TAO/performance-tests/Cubit/Orbix/client/cubitC.cpp b/TAO/performance-tests/Cubit/Orbix/client/cubitC.cpp new file mode 100644 index 00000000000..0913c5bb786 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/client/cubitC.cpp @@ -0,0 +1,561 @@ +// $Id$ + +#include "cubit.h" + +ACE_RCSID(client, cubitC, "$Id$") + +Cubit::Cubit (char *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} +Cubit::Cubit (ObjectReference *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} + +#ifndef CubitForwC +#define CubitForwC +CORBA::ObjectRef Cubit_getBase(void *IT_p){ + return (Cubit*) IT_p;} + +void Cubit_release (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + CORBA::release(IT_p, IT_env);} + +void Cubit_release (Cubit_ptr IT_p) { + Cubit_release (IT_p, CORBA::IT_chooseDefaultEnv ()); } + +Cubit_ptr Cubit_nil (CORBA::Environment &) { + return Cubit:: _nil ();} + +Cubit_ptr Cubit_nil () { + return Cubit_nil (CORBA::IT_chooseDefaultEnv ());} + +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + return (Cubit::_duplicate(IT_p, IT_env)); } +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p) { + return Cubit_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); } +#endif + +Cubit_ptr Cubit::_duplicate(Cubit_ptr obj, CORBA::Environment& IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (!obj) { + return (obj); + } + Cubit_ptr IT_obj = obj->__duplicate (IT_env); + return IT_obj; +} + + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env) { + return (Cubit*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, + Cubit_IMPL, Cubit_IR); +} + + + +Cubit* Cubit:: _bind (CORBA::Environment &IT_env) { + return _bind (NULL,NULL,CORBA::Context(), IT_env); } + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + CORBA::Environment &IT_env) { + return _bind (IT_markerServer, host, CORBA::Context (), IT_env); } +Cubit* Cubit::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (CORBA::is_nil (IT_obj)) { + return Cubit:: _nil(); + } + + Cubit* IT_p = (Cubit*)CORBA::Object::_castDown (IT_obj, Cubit_IR, IT_env); + IT_p = IT_p ? IT_p->__duplicate(IT_env) : NULL; + if ((IT_env) &&(!strcmp(IT_env.exception()->id(), "CORBA::StExcep::BAD_PARAM")) && (((CORBA::BAD_PARAM*)IT_env.exception())-> minor() == NARROW_FAILED)) { + IT_env.exception_free(); + } + return IT_p; + } + + +#ifndef Cubit_Many_Ops +#define Cubit_Many_Ops + +void Cubit::Many:: encodeOp (CORBA::Request &IT_r) const { + + IT_r.insertOctet (o); + + IT_r << l; + + IT_r << s; +} + +void Cubit::Many:: decodeOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +void Cubit::Many:: decodeInOutOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +Cubit::Many ::~Many () { +} + +Cubit::Many:: Many (const Cubit::Many &IT_s) + { + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; +} + +Cubit::Many:: Many () { +} + +Cubit::Many &Cubit::Many:: operator= (const Cubit::Many& IT_s) { + if (this == &IT_s) return *this; + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; + return *this; +} + + +#endif + + +#ifndef Cubit_oneof_Ops +#define Cubit_oneof_Ops +void Cubit::oneof:: encodeOp (CORBA::Request &IT_r) const { + if (!isSet) return; + { + CORBA::ULong IT_0 = (CORBA::ULong) __d; + IT_r << IT_0; + } + switch (__d) { + case Cubit::e_0th: + IT_r.insertOctet (_o_); + break; + case Cubit::e_1st: + IT_r << _s_; + break; + case Cubit::e_2nd: + IT_r << _l_; + break; + case Cubit::e_3rd: + default: + (*_cm_).encodeOp (IT_r); + break; + } + +} + +void Cubit::oneof:: decodeOp (CORBA::Request &IT_r) { + isSet = 0; + { + CORBA::ULong IT_1; + IT_r >> IT_1; + __d = Cubit::discrim(IT_1); + } + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + +} +void Cubit::oneof:: decodeInOutOp (CORBA::Request &IT_r) { + Cubit::discrim IT_d; + { + CORBA::ULong IT_2; + IT_r >> IT_2; + IT_d = Cubit::discrim(IT_2); + } + if (IT_d == __d) + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeInOutOp (IT_r); + break; + } + + else { + this->oneof:: ~oneof(); + memset(this, 0, sizeof(*this)); + __d = IT_d; + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + isSet = 1; + } + +} + +Cubit::oneof:: oneof() { + memset(this, 0, sizeof(*this)); + isSet = 0; +} + +Cubit::oneof ::~oneof() { + if (!isSet) return; + switch (__d) { + case Cubit::e_0th: break; + case Cubit::e_1st: break; + case Cubit::e_2nd: break; + case Cubit::e_3rd: + default: if (_cm_) delete _cm_; + break; + } + + isSet = 0; +} + +Cubit::oneof:: oneof (const Cubit::oneof &IT_s) { + isSet = 0; + memset(this, 0, sizeof(*this)); + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; +} + +Cubit::oneof& Cubit::oneof:: operator= (const Cubit::oneof & IT_s) { + if (this == &IT_s) return *this; + if (isSet && (__d != IT_s.__d)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; + return *this; +} + + +#endif + +void* CubitProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New2 () { + return new class Cubit((char*)0);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::New2Object () { + return new class Cubit((char*)0);} + +void* CubitProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env) { + void *IT_l; + if (!CORBA::_interfaceCmp (IT_s,Cubit_IR, IT_env)) + return IT_p; + else if (IT_l=CORBA::ObjectFactoryClass::IT_castUp((CORBA::Object*)((class Cubit*)IT_p),IT_s, IT_env)) + return IT_l; + else return NULL; + } + + +CORBA::PPTR* CubitProxyFactoryClass::pptr (void *IT_p) { + return ((class Cubit*)IT_p)->_pptr ();} + +void CubitProxyFactoryClass::baseInterfaces (_IDL_SEQUENCE_string& seq) { + add (seq, Cubit_IR); + CORBA::ObjectFactoryClass::baseInterfaces (seq); +} + +CubitProxyFactoryClass CubitProxyFactory(1); + +CORBA::Octet Cubit:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_octet",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r.insertOctet (o); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Octet IT_result; + IT_r.extractOctet (IT_result); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Short Cubit:: cube_short (CORBA::Short s, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_short",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << s; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Short IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Long Cubit:: cube_long (CORBA::Long l, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_long",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << l; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Long IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +Cubit::Many Cubit:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::Many IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_struct",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::Many IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::Many IT_l1; + return IT_l1; + } +} + +Cubit::oneof Cubit:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::oneof IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_union",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::oneof IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::oneof IT_l1; + return IT_l1; + } +} + +void Cubit:: please_exit (CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return ; + } + CORBA::Request IT_r (this, "please_exit",IT_env,1,1); + + IT_r.invoke (CORBA::Flags(CORBA::INV_NO_RESPONSE), IT_env); + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } +} + + + + + +#ifndef Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char, void *) { + IT_r.makeRuntimeException1 ("Cubit"); + return 0; +} + +#endif + diff --git a/TAO/performance-tests/Cubit/Orbix/factory_client/Makefile b/TAO/performance-tests/Cubit/Orbix/factory_client/Makefile new file mode 100644 index 00000000000..b1dfde41302 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/factory_client/Makefile @@ -0,0 +1,77 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the ACE_MT_CORBA_Handler tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +SRC = cubitC.cpp client.cpp + +CLT_OBJS = cubitC.o client.o + +LDLIBS = + +VLDLIBS = $(LDLIBS:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU +include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#---------------------------------------------------------------------------- +# Orbix related macros and target settings. +#---------------------------------------------------------------------------- + + +ORBIX_BINDIR = $(ORBIX_ROOT)/bin +ORBIX_LIBDIR = $(ORBIX_ROOT)/corba2/lib +ORBIX_INCDIR = $(ORBIX_ROOT)/corba2/include + +CPPFLAGS += -DEXCEPTIONS -I$(ORBIX_INCDIR) -DWANT_ORBIX_FDS +LDFLAGS += -L$(ORBIX_LIBDIR) -R $(ORBIX_LIBDIR) -L$(ACE)/ace + +IDLFLAGS = -s S.cpp -c C.cpp -B + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +all: client + +client: $(addprefix $(VDIR),$(CLT_OBJS)) + $(LINK.cc) -o client $(addprefix $(VDIR),$(CLT_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITCLT) $(VLDLIBS) $(POSTLINK) + + +#---------------------------------------------------------------------------- +# Dependencies +#---------------------------------------------------------------------------- +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubitC.o .shobj/cubitC.so: cubitC.cpp cubit.h +.obj/client.o .shobj/client.so: client.cpp $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i cubit.h + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/Orbix/factory_client/client.cpp b/TAO/performance-tests/Cubit/Orbix/factory_client/client.cpp new file mode 100644 index 00000000000..d39892c91fe --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/factory_client/client.cpp @@ -0,0 +1,239 @@ +// $Id$ + +//************************************************************************** +// +// NAME : client.C +// DESCRIPTION: +// +// Client for the Cubit example +// +//**************************************************************************** + +#include "ace/OS.h" +#include "ace/Get_Opt.h" +#include "cubit.h" + +ACE_RCSID(factory_client, client, "$Id$") + +int LOOP_COUNT; +char SERVER_HOST [1024]; + +inline int func (unsigned i) { return i - 117; } +void run_tests (Cubit_var, int); + +// = TITLE +// Parses the command line arguments and returns an error status +// +// = DESCRIPTION +// This method parses the command line arguments +int parse_args(int argc, char *argv[]) +{ + ACE_OS::strcpy (SERVER_HOST, "localhost"); + ACE_Get_Opt opts (argc, argv, "dh:n:O:x"); + int c; + + while ((c = opts ()) != -1) + switch (c) { + case 'h': + ACE_OS::strcpy (SERVER_HOST, opts.optarg); + continue; + case 'd': // debug flag + continue; + + case 'n': // loop count + LOOP_COUNT = (unsigned) ACE_OS::atoi (opts.optarg); + continue; + + case 'O': // stringified objref + continue; + + case 'x': + continue; + + case '?': + default: + ACE_OS::fprintf (stderr, "usage: %s" + " [-d]" + " [-n loopcount]" + " [-h SERVER_HOST]" + " [-x]" + "\n", argv [0] + ); + return 1; + } + + return 0; // Indicates successful parsing of command line +} + + +// +// Mainline +// +int +main (int argc, char *argv[]) +{ + if (parse_args (argc, argv) != 0) + return -1; + + Cubit_var cb; + Cubit_Factory_var cf; + + // cout << "attempting to contact server at host " << SERVER_HOST << '\n' ; + + // + // Initialise client's binding to an + // arbitrary cubit server (at some host) + // + TRY { + cf = Cubit_Factory::_bind ("", SERVER_HOST, IT_X); + } + CATCHANY { + cerr << "Binding failed: " << IT_X; + } + ENDTRY; + cb = cf->create_cubit ("My_Cubit"); + + run_tests (cb, LOOP_COUNT); + return 0; +} + + +void +run_tests (Cubit_var cb, int loop_count) +{ + // + // Make the calls in a loop. + // + unsigned i; + unsigned call_count, error_count; + + call_count = 0; + error_count = 0; + + ACE_Time_Value before, after; + + before = ACE_OS::gettimeofday(); + + // + // Cube an octet. + // + + for (i = 0; i < loop_count; i++) + { + + call_count++; + + CORBA::Octet arg_octet = func (i), ret_octet; + + TRY { + ret_octet = cb->cube_octet (arg_octet); + } + CATCHANY { + cerr << "Call failed: " << IT_X; + error_count++; + } + ENDTRY; + arg_octet = arg_octet * arg_octet * arg_octet; + if (arg_octet != ret_octet) { + ACE_OS::printf ("** cube_octet(%d) (--> %d)\n", arg_octet , ret_octet); + error_count++; + } + + + // + // Cube a short. + // + call_count++; + + CORBA::Short arg_short = func (i), ret_short; + + TRY { + ret_short = cb->cube_short (arg_short); + } + CATCHANY { + cerr << "Call failed: " << IT_X; + error_count++; + } + ENDTRY; + arg_short = arg_short * arg_short * arg_short; + if (arg_short != ret_short) { + ACE_OS::printf ("** cube_short(%d) (--> %d)\n", arg_short , ret_short); + error_count++; + } + + // + // Cube a long. + // + + call_count++; + + CORBA::Long arg_long = func (i), ret_long; + + TRY { + ret_long = cb->cube_long (arg_long); + } + CATCHANY { + cerr << "Call failed: " << IT_X; + } + ENDTRY; + arg_long = arg_long * arg_long * arg_long; + if (arg_long != ret_long) { + ACE_OS::printf ("** cube_long(%d) (--> %d)\n", arg_long , ret_long); + error_count++; + } + + + // + // Cube a "struct" ... + // + Cubit::Many arg_struct, ret_struct; + + call_count++; + + arg_struct.l = func (i); + arg_struct.s = func (i); + arg_struct.o = func (i); + + TRY { + ret_struct = cb->cube_struct (arg_struct); + } + CATCHANY { + cerr << "Call failed: " << IT_X; + error_count++; + } + ENDTRY; + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l ; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s ; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o ; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o ) + { + cerr << "** cube_struct ERROR\n"; + error_count++; + } + } + + + after = ACE_OS::gettimeofday(); + + if (call_count > 0) + { + if (error_count == 0) + { + ACE_Time_Value diff = after - before; + unsigned long us = diff.sec() * 1000 * 1000 + diff.usec(); + + us /= call_count; + + if (us > 0) + ACE_OS::printf ("cube average call ACE_OS::time\t= %ld.%.03ldms, \t" + "%ld calls/second\n", + us / 1000, us % 1000, + 1000000L / us); + } + + ACE_OS::printf ("%d calls, %d errors\n", call_count, error_count); + } +} diff --git a/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.h b/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.h new file mode 100644 index 00000000000..3a2dd546608 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.h @@ -0,0 +1,1113 @@ +// $Id$ + + +#ifndef cubit_hh +#define cubit_hh + +#include <CORBA.h> + +#include <string.h> + + +#ifndef _Cubit_defined +#define _Cubit_defined +class Cubit_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch () {} + + Cubit_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit; + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + + +#ifndef CubitForwH +#define CubitForwH +CORBA::ObjectRef Cubit_getBase (void *); +void Cubit_release (Cubit *, CORBA::Environment &IT_env); +void Cubit_release (Cubit_ptr); +Cubit* Cubit_duplicate (Cubit_ptr, CORBA::Environment &IT_env); +Cubit* Cubit_duplicate (Cubit_ptr ); +Cubit_ptr Cubit_nil (CORBA::Environment &IT_env); +Cubit_ptr Cubit_nil (); +#endif +#define Cubit_IMPL "Cubit" + + +class Cubit; + +typedef Cubit CubitProxy; +#define Cubit_IR "Cubit$v1.1" +#define Cubit_IMPL "Cubit" + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + +class Cubit: public virtual CORBA::Object { +public: + Cubit (char *IT_OR); + Cubit (ObjectReference *IT_OR); + Cubit () : CORBA::Object (1) {} +protected: + Cubit_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_ptr _duplicate( + Cubit_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _bind (CORBA::Environment &IT_env); + static Cubit* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_ptr) CORBA::OBJECT_NIL;} + +#ifndef Cubit_Many_defined +#define Cubit_Many_defined + +struct Many { + CORBA::Octet o; + CORBA::Long l; + CORBA::Short s; + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + Many(const Many &); + Many(); + ~Many(); + Many& operator= (const Many&); +}; + +#ifndef Cubit_ManyVarH +#define Cubit_ManyVarH + +#ifndef Cubit_ManyvPtr +#define Cubit_ManyvPtr +typedef Many* Many_vPtr; +typedef const Many* Many_cvPtr; +#endif + +class Many_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Many_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + Many_var (const Many_var &IT_s) { + (void) copyHelper (IT_s); + } + + Many_var () { + _ptr = new Many; +; + } + + Many_var (Many *IT_p) { + _ptr = IT_p; + } + + Many_var &operator= (Many *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + Many_var &operator= (const Many_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~Many_var () { + delete _ptr; + } + + Many* operator-> () { + return _ptr; + } + + operator Many_cvPtr () const { return _ptr;} + operator Many_vPtr& () { return _ptr;} + operator Many& () const { return * _ptr;} + + protected: + Many *_ptr; + private: + Many_var &operator= (const CORBA::_var &IT_s); + Many_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + +enum discrim {e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th, IT__ENUM_Cubit_discrim=CORBA_ULONG_MAX}; + +#ifndef Cubit_oneof_defined +#define Cubit_oneof_defined + +struct oneof { + private: + + discrim __d; + union { + CORBA::Octet _o_; + CORBA::Short _s_; + CORBA::Long _l_; + Many * _cm_; + }; + + public: + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + + private: + + unsigned char isSet; + + public: + + discrim _d () const { return __d; } + + CORBA::Octet o () const { + return _o_; + } + + void o (CORBA::Octet IT_member) { + if (isSet && (__d != Cubit::e_0th)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_0th; + isSet = 1; + _o_ = IT_member; + } + + CORBA::Short s () const { + return _s_; + } + + void s (CORBA::Short IT_member) { + if (isSet && (__d != Cubit::e_1st)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_1st; + isSet = 1; + _s_ = IT_member; + } + + CORBA::Long l () const { + return _l_; + } + + void l (CORBA::Long IT_member) { + if (isSet && (__d != Cubit::e_2nd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_2nd; + isSet = 1; + _l_ = IT_member; + } + + Many& cm () { + return (*_cm_); + } + + const Many& cm () const { + return (*_cm_); + } + + void cm (const Many& IT_member) { + if (isSet && (__d != Cubit::e_3rd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_3rd; + + if (!isSet) { + _cm_ = new Many; + isSet = 1; + } + *(_cm_) = IT_member; + } + + + oneof(); + oneof(const oneof &); + ~oneof(); + oneof& operator= (const oneof&); +}; + +#ifndef Cubit_oneofVarH +#define Cubit_oneofVarH + +#ifndef Cubit_oneofvPtr +#define Cubit_oneofvPtr +typedef oneof* oneof_vPtr; +typedef const oneof* oneof_cvPtr; +#endif + +class oneof_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const oneof_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + oneof_var (const oneof_var &IT_s) { + (void) copyHelper (IT_s); + } + + oneof_var () { + _ptr = NULL; + } + + oneof_var (oneof *IT_p) { + _ptr = IT_p; + } + + oneof_var &operator= (oneof *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + oneof_var &operator= (const oneof_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~oneof_var () { + delete _ptr; + } + + oneof* operator-> () { + return _ptr; + } + + operator oneof_cvPtr () const { return _ptr;} + operator oneof_vPtr& () { return _ptr;} + operator oneof& () const { return * _ptr;} + + protected: + oneof *_ptr; + private: + oneof_var &operator= (const CORBA::_var &IT_s); + oneof_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef CubitVarH +#define CubitVarH + +#ifndef CubitvPtr +#define CubitvPtr +typedef Cubit* Cubit_vPtr; +typedef const Cubit* Cubit_cvPtr; +#endif + +class Cubit_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_var &IT_s) { + { + _ptr = Cubit_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_var (const Cubit_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_var () { + _ptr = Cubit_nil (); + } + + Cubit_var (Cubit *IT_p) { + _ptr = IT_p; + } + + Cubit_var &operator= (Cubit *IT_p) { + Cubit_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_var &operator= (const Cubit_var &IT_s) { + Cubit_release (_ptr); + _ptr = Cubit_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_var () { + Cubit_release (_ptr); + } + + Cubit* operator-> () { + return _ptr; + } + + operator Cubit_cvPtr () const { return _ptr;} + operator Cubit_vPtr& () { return _ptr;} + + protected: + Cubit *_ptr; + private: + Cubit_var &operator= (const CORBA::_var &IT_s); + Cubit_var (const CORBA::_var &IT_s); + Cubit_var &operator= (const CORBA::_mgr &IT_s); + Cubit_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_var (const CORBA::_mgr &IT_s); + Cubit_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef CubitMgrH +#define CubitMgrH + +class Cubit_mgr : public CORBA::_mgr +{ + public: + + Cubit_mgr () { + _ptr = Cubit_nil (); + _release = 1; + } + + Cubit_mgr (const Cubit_mgr &IT_s) { + _ptr = Cubit_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_mgr &operator= (Cubit *IT_p) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (const Cubit_mgr &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (Cubit_var &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_mgr () { + if (_release) + Cubit_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit* () const { + return (Cubit*) _ptr; + } + + Cubit_ptr operator-> () const { + return _ptr; + } + + Cubit *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_mgr Cubit_mgr_IT_const; +#endif + +#ifndef CubitSeqElemH +#define CubitSeqElemH + +class Cubit_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_SeqElem &operator= (Cubit_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_SeqElem &operator= (const Cubit_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = Cubit_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_ptr () const { + return _ptr ? (Cubit_ptr) (*_ptr) : Cubit_nil(); + } + + Cubit_ptr operator->() const { return *_ptr;} + + protected: + Cubit_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit(X) Cubit##X + +#define DEF_TIE_Cubit(X) \ + class Cubit##X : public virtual Cubit { \ + X* m_obj; \ + public: \ + \ + \ + Cubit##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit(), m_obj(objp) { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,m,l,Cubit_IR,m_obj); \ + } \ + Cubit##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit() { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,IT_m,Cubit_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + + + + +class CubitProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + CubitProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern CubitProxyFactoryClass CubitProxyFactory; + +class CubitBOAImpl : public virtual Cubit { +public: + CubitBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_IR)) + m_pptr = new Cubit_dispatch ( (Cubit*)this, + (CORBA::Object*)this, m, l, Cubit_IR, this); +} + + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#ifndef _Cubit_Factory_defined +#define _Cubit_Factory_defined +class Cubit_Factory_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_Factory_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_Factory_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_Factory_dispatch () {} + + Cubit_Factory_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_Factory_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit_Factory; + +#ifndef Cubit_FactoryPtr +#define Cubit_FactoryPtr + +typedef Cubit_Factory* Cubit_Factory_ptr; + +typedef Cubit_Factory* Cubit_FactoryRef; + +#endif + + +#ifndef Cubit_FactoryForwH +#define Cubit_FactoryForwH +CORBA::ObjectRef Cubit_Factory_getBase (void *); +void Cubit_Factory_release (Cubit_Factory *, CORBA::Environment &IT_env); +void Cubit_Factory_release (Cubit_Factory_ptr); +Cubit_Factory* Cubit_Factory_duplicate (Cubit_Factory_ptr, CORBA::Environment &IT_env); +Cubit_Factory* Cubit_Factory_duplicate (Cubit_Factory_ptr ); +Cubit_Factory_ptr Cubit_Factory_nil (CORBA::Environment &IT_env); +Cubit_Factory_ptr Cubit_Factory_nil (); +#endif +#define Cubit_Factory_IMPL "Cubit_Factory" + + +class Cubit_Factory; + +typedef Cubit_Factory Cubit_FactoryProxy; +#define Cubit_Factory_IR "Cubit_Factory" +#define Cubit_Factory_IMPL "Cubit_Factory" + +#ifndef Cubit_FactoryPtr +#define Cubit_FactoryPtr + +typedef Cubit_Factory* Cubit_Factory_ptr; + +typedef Cubit_Factory* Cubit_FactoryRef; + +#endif + +class Cubit_Factory: public virtual CORBA::Object { +public: + Cubit_Factory (char *IT_OR); + Cubit_Factory (ObjectReference *IT_OR); + Cubit_Factory () : CORBA::Object (1) {} +protected: + Cubit_Factory_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_Factory_ptr _duplicate( + Cubit_Factory_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit_Factory* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory* _bind (CORBA::Environment &IT_env); + static Cubit_Factory* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_Factory_ptr) CORBA::OBJECT_NIL;} + virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef Cubit_FactoryVarH +#define Cubit_FactoryVarH + +#ifndef Cubit_FactoryvPtr +#define Cubit_FactoryvPtr +typedef Cubit_Factory* Cubit_Factory_vPtr; +typedef const Cubit_Factory* Cubit_Factory_cvPtr; +#endif + +class Cubit_Factory_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_Factory_var &IT_s) { + { + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_Factory_var (const Cubit_Factory_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_Factory_var () { + _ptr = Cubit_Factory_nil (); + } + + Cubit_Factory_var (Cubit_Factory *IT_p) { + _ptr = IT_p; + } + + Cubit_Factory_var &operator= (Cubit_Factory *IT_p) { + Cubit_Factory_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_Factory_var &operator= (const Cubit_Factory_var &IT_s) { + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_Factory_var () { + Cubit_Factory_release (_ptr); + } + + Cubit_Factory* operator-> () { + return _ptr; + } + + operator Cubit_Factory_cvPtr () const { return _ptr;} + operator Cubit_Factory_vPtr& () { return _ptr;} + + protected: + Cubit_Factory *_ptr; + private: + Cubit_Factory_var &operator= (const CORBA::_var &IT_s); + Cubit_Factory_var (const CORBA::_var &IT_s); + Cubit_Factory_var &operator= (const CORBA::_mgr &IT_s); + Cubit_Factory_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_Factory_var (const CORBA::_mgr &IT_s); + Cubit_Factory_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef Cubit_FactoryMgrH +#define Cubit_FactoryMgrH + +class Cubit_Factory_mgr : public CORBA::_mgr +{ + public: + + Cubit_Factory_mgr () { + _ptr = Cubit_Factory_nil (); + _release = 1; + } + + Cubit_Factory_mgr (const Cubit_Factory_mgr &IT_s) { + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_Factory_mgr &operator= (Cubit_Factory *IT_p) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_Factory_mgr &operator= (const Cubit_Factory_mgr &IT_s) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_Factory_mgr &operator= (Cubit_Factory_var &IT_s) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_Factory_mgr () { + if (_release) + Cubit_Factory_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit_Factory* () const { + return (Cubit_Factory*) _ptr; + } + + Cubit_Factory_ptr operator-> () const { + return _ptr; + } + + Cubit_Factory *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_Factory_mgr Cubit_Factory_mgr_IT_const; +#endif + +#ifndef Cubit_FactorySeqElemH +#define Cubit_FactorySeqElemH + +class Cubit_Factory_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_Factory_SeqElem (Cubit_Factory_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_Factory_SeqElem &operator= (Cubit_Factory_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_Factory_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_Factory_SeqElem &operator= (const Cubit_Factory_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_Factory_release (*(_ptr)); + *(_ptr) = Cubit_Factory_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_Factory_ptr () const { + return _ptr ? (Cubit_Factory_ptr) (*_ptr) : Cubit_Factory_nil(); + } + + Cubit_Factory_ptr operator->() const { return *_ptr;} + + protected: + Cubit_Factory_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit_Factory(X) Cubit_Factory##X + +#define DEF_TIE_Cubit_Factory(X) \ + class Cubit_Factory##X : public virtual Cubit_Factory { \ + X* m_obj; \ + public: \ + \ + \ + Cubit_Factory##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit_Factory(), m_obj(objp) { \ + m_pptr = new Cubit_Factory_dispatch \ + (( Cubit_Factory*)this,(CORBA::Object*)this,m,l,Cubit_Factory_IR,m_obj); \ + } \ + Cubit_Factory##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit_Factory() { \ + m_pptr = new Cubit_Factory_dispatch \ + (( Cubit_Factory*)this,(CORBA::Object*)this,IT_m,Cubit_Factory_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit_Factory##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->create_cubit ( name,IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit_Factory \ +virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->create_cubit ( name,IT_env);\ +}\ + + + + +class Cubit_FactoryProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + Cubit_FactoryProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_Factory_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern Cubit_FactoryProxyFactoryClass Cubit_FactoryProxyFactory; + +class Cubit_FactoryBOAImpl : public virtual Cubit_Factory { +public: + Cubit_FactoryBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_Factory_IR)) + m_pptr = new Cubit_Factory_dispatch ( (Cubit_Factory*)this, + (CORBA::Object*)this, m, l, Cubit_Factory_IR, this); +} + + virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.hh b/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.hh new file mode 100644 index 00000000000..72e2fb81395 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.hh @@ -0,0 +1,1111 @@ + +#ifndef cubit_hh +#define cubit_hh + +#include <CORBA.h> + +#include <string.h> + + +#ifndef _Cubit_defined +#define _Cubit_defined +class Cubit_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch () {} + + Cubit_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit; + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + + +#ifndef CubitForwH +#define CubitForwH +CORBA::ObjectRef Cubit_getBase (void *); +void Cubit_release (Cubit *, CORBA::Environment &IT_env); +void Cubit_release (Cubit_ptr); +Cubit* Cubit_duplicate (Cubit_ptr, CORBA::Environment &IT_env); +Cubit* Cubit_duplicate (Cubit_ptr ); +Cubit_ptr Cubit_nil (CORBA::Environment &IT_env); +Cubit_ptr Cubit_nil (); +#endif +#define Cubit_IMPL "Cubit" + + +class Cubit; + +typedef Cubit CubitProxy; +#define Cubit_IR "Cubit$v1.1" +#define Cubit_IMPL "Cubit" + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + +class Cubit: public virtual CORBA::Object { +public: + Cubit (char *IT_OR); + Cubit (ObjectReference *IT_OR); + Cubit () : CORBA::Object (1) {} +protected: + Cubit_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_ptr _duplicate( + Cubit_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _bind (CORBA::Environment &IT_env); + static Cubit* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_ptr) CORBA::OBJECT_NIL;} + +#ifndef Cubit_Many_defined +#define Cubit_Many_defined + +struct Many { + CORBA::Octet o; + CORBA::Long l; + CORBA::Short s; + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + Many(const Many &); + Many(); + ~Many(); + Many& operator= (const Many&); +}; + +#ifndef Cubit_ManyVarH +#define Cubit_ManyVarH + +#ifndef Cubit_ManyvPtr +#define Cubit_ManyvPtr +typedef Many* Many_vPtr; +typedef const Many* Many_cvPtr; +#endif + +class Many_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Many_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + Many_var (const Many_var &IT_s) { + (void) copyHelper (IT_s); + } + + Many_var () { + _ptr = new Many; +; + } + + Many_var (Many *IT_p) { + _ptr = IT_p; + } + + Many_var &operator= (Many *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + Many_var &operator= (const Many_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~Many_var () { + delete _ptr; + } + + Many* operator-> () { + return _ptr; + } + + operator Many_cvPtr () const { return _ptr;} + operator Many_vPtr& () { return _ptr;} + operator Many& () const { return * _ptr;} + + protected: + Many *_ptr; + private: + Many_var &operator= (const CORBA::_var &IT_s); + Many_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + +enum discrim {e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th, IT__ENUM_Cubit_discrim=CORBA_ULONG_MAX}; + +#ifndef Cubit_oneof_defined +#define Cubit_oneof_defined + +struct oneof { + private: + + discrim __d; + union { + CORBA::Octet _o_; + CORBA::Short _s_; + CORBA::Long _l_; + Many * _cm_; + }; + + public: + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + + private: + + unsigned char isSet; + + public: + + discrim _d () const { return __d; } + + CORBA::Octet o () const { + return _o_; + } + + void o (CORBA::Octet IT_member) { + if (isSet && (__d != Cubit::e_0th)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_0th; + isSet = 1; + _o_ = IT_member; + } + + CORBA::Short s () const { + return _s_; + } + + void s (CORBA::Short IT_member) { + if (isSet && (__d != Cubit::e_1st)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_1st; + isSet = 1; + _s_ = IT_member; + } + + CORBA::Long l () const { + return _l_; + } + + void l (CORBA::Long IT_member) { + if (isSet && (__d != Cubit::e_2nd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_2nd; + isSet = 1; + _l_ = IT_member; + } + + Many& cm () { + return (*_cm_); + } + + const Many& cm () const { + return (*_cm_); + } + + void cm (const Many& IT_member) { + if (isSet && (__d != Cubit::e_3rd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_3rd; + + if (!isSet) { + _cm_ = new Many; + isSet = 1; + } + *(_cm_) = IT_member; + } + + + oneof(); + oneof(const oneof &); + ~oneof(); + oneof& operator= (const oneof&); +}; + +#ifndef Cubit_oneofVarH +#define Cubit_oneofVarH + +#ifndef Cubit_oneofvPtr +#define Cubit_oneofvPtr +typedef oneof* oneof_vPtr; +typedef const oneof* oneof_cvPtr; +#endif + +class oneof_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const oneof_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + oneof_var (const oneof_var &IT_s) { + (void) copyHelper (IT_s); + } + + oneof_var () { + _ptr = NULL; + } + + oneof_var (oneof *IT_p) { + _ptr = IT_p; + } + + oneof_var &operator= (oneof *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + oneof_var &operator= (const oneof_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~oneof_var () { + delete _ptr; + } + + oneof* operator-> () { + return _ptr; + } + + operator oneof_cvPtr () const { return _ptr;} + operator oneof_vPtr& () { return _ptr;} + operator oneof& () const { return * _ptr;} + + protected: + oneof *_ptr; + private: + oneof_var &operator= (const CORBA::_var &IT_s); + oneof_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef CubitVarH +#define CubitVarH + +#ifndef CubitvPtr +#define CubitvPtr +typedef Cubit* Cubit_vPtr; +typedef const Cubit* Cubit_cvPtr; +#endif + +class Cubit_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_var &IT_s) { + { + _ptr = Cubit_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_var (const Cubit_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_var () { + _ptr = Cubit_nil (); + } + + Cubit_var (Cubit *IT_p) { + _ptr = IT_p; + } + + Cubit_var &operator= (Cubit *IT_p) { + Cubit_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_var &operator= (const Cubit_var &IT_s) { + Cubit_release (_ptr); + _ptr = Cubit_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_var () { + Cubit_release (_ptr); + } + + Cubit* operator-> () { + return _ptr; + } + + operator Cubit_cvPtr () const { return _ptr;} + operator Cubit_vPtr& () { return _ptr;} + + protected: + Cubit *_ptr; + private: + Cubit_var &operator= (const CORBA::_var &IT_s); + Cubit_var (const CORBA::_var &IT_s); + Cubit_var &operator= (const CORBA::_mgr &IT_s); + Cubit_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_var (const CORBA::_mgr &IT_s); + Cubit_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef CubitMgrH +#define CubitMgrH + +class Cubit_mgr : public CORBA::_mgr +{ + public: + + Cubit_mgr () { + _ptr = Cubit_nil (); + _release = 1; + } + + Cubit_mgr (const Cubit_mgr &IT_s) { + _ptr = Cubit_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_mgr &operator= (Cubit *IT_p) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (const Cubit_mgr &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (Cubit_var &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_mgr () { + if (_release) + Cubit_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit* () const { + return (Cubit*) _ptr; + } + + Cubit_ptr operator-> () const { + return _ptr; + } + + Cubit *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_mgr Cubit_mgr_IT_const; +#endif + +#ifndef CubitSeqElemH +#define CubitSeqElemH + +class Cubit_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_SeqElem &operator= (Cubit_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_SeqElem &operator= (const Cubit_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = Cubit_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_ptr () const { + return _ptr ? (Cubit_ptr) (*_ptr) : Cubit_nil(); + } + + Cubit_ptr operator->() const { return *_ptr;} + + protected: + Cubit_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit(X) Cubit##X + +#define DEF_TIE_Cubit(X) \ + class Cubit##X : public virtual Cubit { \ + X* m_obj; \ + public: \ + \ + \ + Cubit##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit(), m_obj(objp) { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,m,l,Cubit_IR,m_obj); \ + } \ + Cubit##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit() { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,IT_m,Cubit_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + + + + +class CubitProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + CubitProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern CubitProxyFactoryClass CubitProxyFactory; + +class CubitBOAImpl : public virtual Cubit { +public: + CubitBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_IR)) + m_pptr = new Cubit_dispatch ( (Cubit*)this, + (CORBA::Object*)this, m, l, Cubit_IR, this); +} + + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#ifndef _Cubit_Factory_defined +#define _Cubit_Factory_defined +class Cubit_Factory_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_Factory_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_Factory_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_Factory_dispatch () {} + + Cubit_Factory_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_Factory_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit_Factory; + +#ifndef Cubit_FactoryPtr +#define Cubit_FactoryPtr + +typedef Cubit_Factory* Cubit_Factory_ptr; + +typedef Cubit_Factory* Cubit_FactoryRef; + +#endif + + +#ifndef Cubit_FactoryForwH +#define Cubit_FactoryForwH +CORBA::ObjectRef Cubit_Factory_getBase (void *); +void Cubit_Factory_release (Cubit_Factory *, CORBA::Environment &IT_env); +void Cubit_Factory_release (Cubit_Factory_ptr); +Cubit_Factory* Cubit_Factory_duplicate (Cubit_Factory_ptr, CORBA::Environment &IT_env); +Cubit_Factory* Cubit_Factory_duplicate (Cubit_Factory_ptr ); +Cubit_Factory_ptr Cubit_Factory_nil (CORBA::Environment &IT_env); +Cubit_Factory_ptr Cubit_Factory_nil (); +#endif +#define Cubit_Factory_IMPL "Cubit_Factory" + + +class Cubit_Factory; + +typedef Cubit_Factory Cubit_FactoryProxy; +#define Cubit_Factory_IR "Cubit_Factory" +#define Cubit_Factory_IMPL "Cubit_Factory" + +#ifndef Cubit_FactoryPtr +#define Cubit_FactoryPtr + +typedef Cubit_Factory* Cubit_Factory_ptr; + +typedef Cubit_Factory* Cubit_FactoryRef; + +#endif + +class Cubit_Factory: public virtual CORBA::Object { +public: + Cubit_Factory (char *IT_OR); + Cubit_Factory (ObjectReference *IT_OR); + Cubit_Factory () : CORBA::Object (1) {} +protected: + Cubit_Factory_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_Factory_ptr _duplicate( + Cubit_Factory_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit_Factory* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory* _bind (CORBA::Environment &IT_env); + static Cubit_Factory* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_Factory_ptr) CORBA::OBJECT_NIL;} + virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef Cubit_FactoryVarH +#define Cubit_FactoryVarH + +#ifndef Cubit_FactoryvPtr +#define Cubit_FactoryvPtr +typedef Cubit_Factory* Cubit_Factory_vPtr; +typedef const Cubit_Factory* Cubit_Factory_cvPtr; +#endif + +class Cubit_Factory_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_Factory_var &IT_s) { + { + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_Factory_var (const Cubit_Factory_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_Factory_var () { + _ptr = Cubit_Factory_nil (); + } + + Cubit_Factory_var (Cubit_Factory *IT_p) { + _ptr = IT_p; + } + + Cubit_Factory_var &operator= (Cubit_Factory *IT_p) { + Cubit_Factory_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_Factory_var &operator= (const Cubit_Factory_var &IT_s) { + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_Factory_var () { + Cubit_Factory_release (_ptr); + } + + Cubit_Factory* operator-> () { + return _ptr; + } + + operator Cubit_Factory_cvPtr () const { return _ptr;} + operator Cubit_Factory_vPtr& () { return _ptr;} + + protected: + Cubit_Factory *_ptr; + private: + Cubit_Factory_var &operator= (const CORBA::_var &IT_s); + Cubit_Factory_var (const CORBA::_var &IT_s); + Cubit_Factory_var &operator= (const CORBA::_mgr &IT_s); + Cubit_Factory_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_Factory_var (const CORBA::_mgr &IT_s); + Cubit_Factory_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef Cubit_FactoryMgrH +#define Cubit_FactoryMgrH + +class Cubit_Factory_mgr : public CORBA::_mgr +{ + public: + + Cubit_Factory_mgr () { + _ptr = Cubit_Factory_nil (); + _release = 1; + } + + Cubit_Factory_mgr (const Cubit_Factory_mgr &IT_s) { + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_Factory_mgr &operator= (Cubit_Factory *IT_p) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_Factory_mgr &operator= (const Cubit_Factory_mgr &IT_s) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_Factory_mgr &operator= (Cubit_Factory_var &IT_s) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_Factory_mgr () { + if (_release) + Cubit_Factory_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit_Factory* () const { + return (Cubit_Factory*) _ptr; + } + + Cubit_Factory_ptr operator-> () const { + return _ptr; + } + + Cubit_Factory *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_Factory_mgr Cubit_Factory_mgr_IT_const; +#endif + +#ifndef Cubit_FactorySeqElemH +#define Cubit_FactorySeqElemH + +class Cubit_Factory_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_Factory_SeqElem (Cubit_Factory_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_Factory_SeqElem &operator= (Cubit_Factory_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_Factory_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_Factory_SeqElem &operator= (const Cubit_Factory_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_Factory_release (*(_ptr)); + *(_ptr) = Cubit_Factory_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_Factory_ptr () const { + return _ptr ? (Cubit_Factory_ptr) (*_ptr) : Cubit_Factory_nil(); + } + + Cubit_Factory_ptr operator->() const { return *_ptr;} + + protected: + Cubit_Factory_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit_Factory(X) Cubit_Factory##X + +#define DEF_TIE_Cubit_Factory(X) \ + class Cubit_Factory##X : public virtual Cubit_Factory { \ + X* m_obj; \ + public: \ + \ + \ + Cubit_Factory##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit_Factory(), m_obj(objp) { \ + m_pptr = new Cubit_Factory_dispatch \ + (( Cubit_Factory*)this,(CORBA::Object*)this,m,l,Cubit_Factory_IR,m_obj); \ + } \ + Cubit_Factory##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit_Factory() { \ + m_pptr = new Cubit_Factory_dispatch \ + (( Cubit_Factory*)this,(CORBA::Object*)this,IT_m,Cubit_Factory_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit_Factory##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->create_cubit ( name,IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit_Factory \ +virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->create_cubit ( name,IT_env);\ +}\ + + + + +class Cubit_FactoryProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + Cubit_FactoryProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_Factory_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern Cubit_FactoryProxyFactoryClass Cubit_FactoryProxyFactory; + +class Cubit_FactoryBOAImpl : public virtual Cubit_Factory { +public: + Cubit_FactoryBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_Factory_IR)) + m_pptr = new Cubit_Factory_dispatch ( (Cubit_Factory*)this, + (CORBA::Object*)this, m, l, Cubit_Factory_IR, this); +} + + virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.idl b/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.idl new file mode 100644 index 00000000000..41309e997ea --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/factory_client/cubit.idl @@ -0,0 +1,48 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. + +#pragma prefix "Eng.SUN.COM" +#pragma version Cubit 1.1 + + interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); + }; + + + interface Cubit_Factory { + Cubit create_cubit (in string name); + }; + diff --git a/TAO/performance-tests/Cubit/Orbix/factory_client/cubitC.cpp b/TAO/performance-tests/Cubit/Orbix/factory_client/cubitC.cpp new file mode 100644 index 00000000000..e265863e99a --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/factory_client/cubitC.cpp @@ -0,0 +1,714 @@ +// $Id$ + + + +#include "cubit.h" + +ACE_RCSID(factory_client, cubitC, "$Id$") + +Cubit::Cubit (char *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} +Cubit::Cubit (ObjectReference *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} + +#ifndef CubitForwC +#define CubitForwC +CORBA::ObjectRef Cubit_getBase(void *IT_p){ + return (Cubit*) IT_p;} + +void Cubit_release (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + CORBA::release(IT_p, IT_env);} + +void Cubit_release (Cubit_ptr IT_p) { + Cubit_release (IT_p, CORBA::IT_chooseDefaultEnv ()); } + +Cubit_ptr Cubit_nil (CORBA::Environment &) { + return Cubit:: _nil ();} + +Cubit_ptr Cubit_nil () { + return Cubit_nil (CORBA::IT_chooseDefaultEnv ());} + +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + return (Cubit::_duplicate(IT_p, IT_env)); } +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p) { + return Cubit_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); } +#endif + +Cubit_ptr Cubit::_duplicate(Cubit_ptr obj, CORBA::Environment& IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (!obj) { + return (obj); + } + Cubit_ptr IT_obj = obj->__duplicate (IT_env); + return IT_obj; +} + + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env) { + return (Cubit*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, + Cubit_IMPL, Cubit_IR); +} + + + +Cubit* Cubit:: _bind (CORBA::Environment &IT_env) { + return _bind (NULL,NULL,CORBA::Context(), IT_env); } + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + CORBA::Environment &IT_env) { + return _bind (IT_markerServer, host, CORBA::Context (), IT_env); } +Cubit* Cubit::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (CORBA::is_nil (IT_obj)) { + return Cubit:: _nil(); + } + + Cubit* IT_p = (Cubit*)CORBA::Object::_castDown (IT_obj, Cubit_IR, IT_env); + IT_p = IT_p ? IT_p->__duplicate(IT_env) : NULL; + if ((IT_env) &&(!strcmp(IT_env.exception()->id(), "CORBA::StExcep::BAD_PARAM")) && (((CORBA::BAD_PARAM*)IT_env.exception())-> minor() == NARROW_FAILED)) { + IT_env.exception_free(); + } + return IT_p; + } + + +#ifndef Cubit_Many_Ops +#define Cubit_Many_Ops + +void Cubit::Many:: encodeOp (CORBA::Request &IT_r) const { + + IT_r.insertOctet (o); + + IT_r << l; + + IT_r << s; +} + +void Cubit::Many:: decodeOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +void Cubit::Many:: decodeInOutOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +Cubit::Many ::~Many () { +} + +Cubit::Many:: Many (const Cubit::Many &IT_s) + { + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; +} + +Cubit::Many:: Many () { +} + +Cubit::Many &Cubit::Many:: operator= (const Cubit::Many& IT_s) { + if (this == &IT_s) return *this; + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; + return *this; +} + + +#endif + + +#ifndef Cubit_oneof_Ops +#define Cubit_oneof_Ops +void Cubit::oneof:: encodeOp (CORBA::Request &IT_r) const { + if (!isSet) return; + { + CORBA::ULong IT_0 = (CORBA::ULong) __d; + IT_r << IT_0; + } + switch (__d) { + case Cubit::e_0th: + IT_r.insertOctet (_o_); + break; + case Cubit::e_1st: + IT_r << _s_; + break; + case Cubit::e_2nd: + IT_r << _l_; + break; + case Cubit::e_3rd: + default: + (*_cm_).encodeOp (IT_r); + break; + } + +} + +void Cubit::oneof:: decodeOp (CORBA::Request &IT_r) { + isSet = 0; + { + CORBA::ULong IT_1; + IT_r >> IT_1; + __d = Cubit::discrim(IT_1); + } + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + +} +void Cubit::oneof:: decodeInOutOp (CORBA::Request &IT_r) { + Cubit::discrim IT_d; + { + CORBA::ULong IT_2; + IT_r >> IT_2; + IT_d = Cubit::discrim(IT_2); + } + if (IT_d == __d) + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeInOutOp (IT_r); + break; + } + + else { + this->oneof:: ~oneof(); + memset(this, 0, sizeof(*this)); + __d = IT_d; + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + isSet = 1; + } + +} + +Cubit::oneof:: oneof() { + memset(this, 0, sizeof(*this)); + isSet = 0; +} + +Cubit::oneof ::~oneof() { + if (!isSet) return; + switch (__d) { + case Cubit::e_0th: break; + case Cubit::e_1st: break; + case Cubit::e_2nd: break; + case Cubit::e_3rd: + default: if (_cm_) delete _cm_; + break; + } + + isSet = 0; +} + +Cubit::oneof:: oneof (const Cubit::oneof &IT_s) { + isSet = 0; + memset(this, 0, sizeof(*this)); + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; +} + +Cubit::oneof& Cubit::oneof:: operator= (const Cubit::oneof & IT_s) { + if (this == &IT_s) return *this; + if (isSet && (__d != IT_s.__d)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; + return *this; +} + + +#endif + +void* CubitProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New2 () { + return new class Cubit((char*)0);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::New2Object () { + return new class Cubit((char*)0);} + +void* CubitProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env) { + void *IT_l; + if (!CORBA::_interfaceCmp (IT_s,Cubit_IR, IT_env)) + return IT_p; + else if (IT_l=CORBA::ObjectFactoryClass::IT_castUp((CORBA::Object*)((class Cubit*)IT_p),IT_s, IT_env)) + return IT_l; + else return NULL; + } + + +CORBA::PPTR* CubitProxyFactoryClass::pptr (void *IT_p) { + return ((class Cubit*)IT_p)->_pptr ();} + +void CubitProxyFactoryClass::baseInterfaces (_IDL_SEQUENCE_string& seq) { + add (seq, Cubit_IR); + CORBA::ObjectFactoryClass::baseInterfaces (seq); +} + +CubitProxyFactoryClass CubitProxyFactory(1); + +CORBA::Octet Cubit:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_octet",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r.insertOctet (o); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Octet IT_result; + IT_r.extractOctet (IT_result); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Short Cubit:: cube_short (CORBA::Short s, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_short",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << s; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Short IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Long Cubit:: cube_long (CORBA::Long l, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_long",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << l; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Long IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +Cubit::Many Cubit:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::Many IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_struct",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::Many IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::Many IT_l1; + return IT_l1; + } +} + +Cubit::oneof Cubit:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::oneof IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_union",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::oneof IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::oneof IT_l1; + return IT_l1; + } +} + +void Cubit:: please_exit (CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return ; + } + CORBA::Request IT_r (this, "please_exit",IT_env,1,1); + + IT_r.invoke (CORBA::Flags(CORBA::INV_NO_RESPONSE), IT_env); + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } +} + + + + + +#ifndef Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char, void *) { + IT_r.makeRuntimeException1 ("Cubit"); + return 0; +} + +#endif + +Cubit_Factory::Cubit_Factory (char *IT_OR) { + m_pptr = new Cubit_Factory_dispatch (IT_OR, this,(CORBA::Object*)this); +} +Cubit_Factory::Cubit_Factory (ObjectReference *IT_OR) { + m_pptr = new Cubit_Factory_dispatch (IT_OR, this,(CORBA::Object*)this); +} + +#ifndef Cubit_FactoryForwC +#define Cubit_FactoryForwC +CORBA::ObjectRef Cubit_Factory_getBase(void *IT_p){ + return (Cubit_Factory*) IT_p;} + +void Cubit_Factory_release (Cubit_Factory_ptr IT_p, CORBA::Environment &IT_env) { + CORBA::release(IT_p, IT_env);} + +void Cubit_Factory_release (Cubit_Factory_ptr IT_p) { + Cubit_Factory_release (IT_p, CORBA::IT_chooseDefaultEnv ()); } + +Cubit_Factory_ptr Cubit_Factory_nil (CORBA::Environment &) { + return Cubit_Factory:: _nil ();} + +Cubit_Factory_ptr Cubit_Factory_nil () { + return Cubit_Factory_nil (CORBA::IT_chooseDefaultEnv ());} + +Cubit_Factory_ptr Cubit_Factory_duplicate (Cubit_Factory_ptr IT_p, CORBA::Environment &IT_env) { + return (Cubit_Factory::_duplicate(IT_p, IT_env)); } +Cubit_Factory_ptr Cubit_Factory_duplicate (Cubit_Factory_ptr IT_p) { + return Cubit_Factory_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); } +#endif + +Cubit_Factory_ptr Cubit_Factory::_duplicate(Cubit_Factory_ptr obj, CORBA::Environment& IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (!obj) { + return (obj); + } + Cubit_Factory_ptr IT_obj = obj->__duplicate (IT_env); + return IT_obj; +} + + + +Cubit_Factory* Cubit_Factory:: _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env) { + return (Cubit_Factory*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, + Cubit_Factory_IMPL, Cubit_Factory_IR); +} + + + +Cubit_Factory* Cubit_Factory:: _bind (CORBA::Environment &IT_env) { + return _bind (NULL,NULL,CORBA::Context(), IT_env); } + + +Cubit_Factory* Cubit_Factory:: _bind (const char* IT_markerServer, const char* host, + CORBA::Environment &IT_env) { + return _bind (IT_markerServer, host, CORBA::Context (), IT_env); } +Cubit_Factory* Cubit_Factory::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (CORBA::is_nil (IT_obj)) { + return Cubit_Factory:: _nil(); + } + + Cubit_Factory* IT_p = (Cubit_Factory*)CORBA::Object::_castDown (IT_obj, Cubit_Factory_IR, IT_env); + IT_p = IT_p ? IT_p->__duplicate(IT_env) : NULL; + if ((IT_env) &&(!strcmp(IT_env.exception()->id(), "CORBA::StExcep::BAD_PARAM")) && (((CORBA::BAD_PARAM*)IT_env.exception())-> minor() == NARROW_FAILED)) { + IT_env.exception_free(); + } + return IT_p; + } + +void* Cubit_FactoryProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) { + return new class Cubit_Factory(IT_OR);} + +void* Cubit_FactoryProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit_Factory(IT_OR);} + +void* Cubit_FactoryProxyFactoryClass::New2 () { + return new class Cubit_Factory((char*)0);} + +CORBA::Object* Cubit_FactoryProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment&) { + return new class Cubit_Factory(IT_OR);} + +CORBA::Object* Cubit_FactoryProxyFactoryClass::NewObject (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit_Factory(IT_OR);} + +CORBA::Object* Cubit_FactoryProxyFactoryClass::New2Object () { + return new class Cubit_Factory((char*)0);} + +void* Cubit_FactoryProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env) { + void *IT_l; + if (!CORBA::_interfaceCmp (IT_s,Cubit_Factory_IR, IT_env)) + return IT_p; + else if (IT_l=CORBA::ObjectFactoryClass::IT_castUp((CORBA::Object*)((class Cubit_Factory*)IT_p),IT_s, IT_env)) + return IT_l; + else return NULL; + } + + +CORBA::PPTR* Cubit_FactoryProxyFactoryClass::pptr (void *IT_p) { + return ((class Cubit_Factory*)IT_p)->_pptr ();} + +void Cubit_FactoryProxyFactoryClass::baseInterfaces (_IDL_SEQUENCE_string& seq) { + add (seq, Cubit_Factory_IR); + CORBA::ObjectFactoryClass::baseInterfaces (seq); +} + +Cubit_FactoryProxyFactoryClass Cubit_FactoryProxyFactory(1); + +Cubit_ptr Cubit_Factory:: create_cubit (const char * name, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return new Cubit; + } + CORBA::Request IT_r (this, "create_cubit",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r.encodeStringOp (name); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit_ptr IT_result; + IT_result = (Cubit*) IT_r.decodeObjRef (Cubit_IR); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return new Cubit; +} + + + + + +#ifndef Cubit_Factory_dispatch_impl + +unsigned char Cubit_Factory_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char, void *) { + IT_r.makeRuntimeException1 ("Cubit_Factory"); + return 0; +} + +#endif + diff --git a/TAO/performance-tests/Cubit/Orbix/factory_client/cubitS.cpp b/TAO/performance-tests/Cubit/Orbix/factory_client/cubitS.cpp new file mode 100644 index 00000000000..f967ad02ee1 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/factory_client/cubitS.cpp @@ -0,0 +1,286 @@ +// $Id$ + + + +#include "cubit.hh" + + +ACE_RCSID(factory_client, cubitS, "$Id$") + +#define Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void *IT_pp) { + if (!IT_pp) + IT_pp = m_obj; + const char *IT_s = IT_r.getOperation (); + if (!strcmp(IT_s,"cube_octet")) { + CORBA::Octet IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_octet~+o{o},>{o},N{}\ +")) + return 1; + CORBA::Octet o; + + IT_r.extractOctet (o); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_octet ( o, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +o\ +", IT_env)) return 1; + IT_r.insertOctet (IT_result); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_short")) { + CORBA::Short IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_short~+s{s},>{s},N{}\ +")) + return 1; + CORBA::Short s; + + IT_r >> s; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_short ( s, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +s\ +", IT_env)) return 1; + IT_r << IT_result; + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_long")) { + CORBA::Long IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_long~+l{l},>{l},N{}\ +")) + return 1; + CORBA::Long l; + + IT_r >> l; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_long ( l, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +l\ +", IT_env)) return 1; + IT_r << IT_result; + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_struct")) { + Cubit::Many IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_struct~+values{R~Cubit::Many~o{o},l{l},s{s}},>{R~Cubit::Many~o{o},l{l},s{s}},N{}\ +")) + return 1; + Cubit::Many values; + + values.decodeOp (IT_r); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_struct ( values, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +R~Cubit::Many~o{o},l{l},s{s}\ +", IT_env)) return 1; + IT_result.encodeOp (IT_r); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_union")) { + Cubit::oneof IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + IT_r.tcPreAssert ( +"\ +Ro~cube_union~+values{U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}},>{U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,\ +"); + if (!IT_r.tcAssert ("\ +e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}},N{}\ +")) + return 1; + Cubit::oneof values; + + values.decodeOp (IT_r); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_union ( values, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}\ +", IT_env)) return 1; + IT_result.encodeOp (IT_r); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"please_exit")) { + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~please_exit~>{v},O{}\ +")) + return 1; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + ((Cubit*)IT_pp)->please_exit (IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env); + return 1; + } + + if (IT_isTarget) + IT_r.makeRuntimeException2 (); + + return 0; +} + +#define Cubit_Factory_dispatch_impl + +unsigned char Cubit_Factory_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void *IT_pp) { + if (!IT_pp) + IT_pp = m_obj; + const char *IT_s = IT_r.getOperation (); + if (!strcmp(IT_s,"create_cubit")) { + Cubit_ptr IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~create_cubit~+name{0},>{O~Cubit},N{}\ +")) + return 1; + char * name; + + IT_r.decodeStringOp(name); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit_Factory*)IT_pp)->create_cubit ( name, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + CORBA::string_free (name); + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +O~Cubit\ +", IT_env)) return 1; + { + CORBA::Object* IT_l1 = (CORBA::Object*) IT_result; + IT_r << IT_l1; + } + if (IT_result) Cubit_release (IT_result); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (IT_isTarget) + IT_r.makeRuntimeException2 (); + + return 0; +} + +#include "cubitC.cpp" + diff --git a/TAO/performance-tests/Cubit/Orbix/orb.mk b/TAO/performance-tests/Cubit/Orbix/orb.mk new file mode 100644 index 00000000000..cf7b12d3b1b --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/orb.mk @@ -0,0 +1,146 @@ +# ------------------------------------------------------------ +# Orbix 2.2 implicit rules for SunOS/GNU Make +# ------------------------------------------------------------ +# +# If you cut'n'paste this into your /usr/include/make/default.mk +# file, beware! This is not officially supported by Iona +# Technologies, and you may want to be a bit of a Makefile hacker +# to make it integrate well with your site's setup. + +# The best thing to do would be put it in a standard place and +# anyone who wants the Orbix implicit rule set can include +# it with an "include <pathname>/orbix.mk" line in their +# Makefile. A good place to put it might be /usr/include/make. + +# These rules define default C++, C++FLAGS and C++SUFFIX. +# C++ is the C++ compiler to use; C++FLAGS are command-line +# flags to the C++ compiler for use in compiling C++ source +# files into objects; C++SUFFIX is the filename suffix +# indicating C++ source. By default, it's set to "C" for AT&T C++, +# and "cc" for GNU g++. + +# Feel free to override these in your Makefiles *after* +# including this file. + +# IMPORTANT: If the -M switch is specified in IDLFLAGS, the IDL +# compiler appends to the user-specified file. The dependency for +# specified_file.o in the linking target should appear _after_ any use +# of the IDL compiler which takes the -M flag. Putting it _last_ +# is normally the best approach. + +# Note that these rule definitions use pattern matching, +# and therefore only work with SunOS make and GNU make. + +# They may not work with other vendor's versions of make. +# If they do not, you may wish to try using GNU make, which +# is free software produced by the Free Software Foundation. + +# If the version of make you wish to use does not support +# pattern matching, use the sample explicit rule set in +# the comments at the end of this file. + +# ------------------------------------------------------------ +# Essential: set these to the locations into which you +# have installed Orbix' components: + +ORBIX_BINDIR = /opt/Orbix_2.2MT/corba2/bin +ORBIX_LIBDIR = /opt/Orbix_2.2MT/corba2/lib +ORBIX_INCDIR = /opt/Orbix_2.2MT/corba2/include + +#------------------------------------------------------------- +# To compile the demos, you should change these values as +# appropriate for your particular system installation +#------------------------------------------------------------- + +X11BASE = /usr/openwin +X11INCDIR = $(X11BASE)/include +X11LIBDIR = $(X11BASE)/lib + +# C++ = CC +# C++FLAGS = -I$(ORBIX_INCDIR) -I. -mt -D_REENTRANT +# C++SUFFIX = cpp + +# ------------------------------------------------------------ +# ITCLT, IRCLT and ITSRV can be either statically or dynamically linked +# Use -Bdynamic or -Bstatic as appropriate. +# ------------------------------------------------------------ + +ITCLT = -Bstatic -lorbixmt +IRCLT = -Bstatic -lIRcltmt +ITSRV = -Bstatic -lorbixmt +ITIIOP = -Bstatic -liiopmt +ITDSI = -Bstatic -lDSImt +ITIFR = -Bstatic -lifrmt + +# ------------------------------------------------------------ +# SYSLIBS must be dynamically linked; otherwise you can expect to +# get linkage errors for symbols in the nsl library +# ------------------------------------------------------------ + +LDFLAGS += -L$(ORBIX_LIBDIR) +SYSLIBS = -Bdynamic -lnsl -lsocket + +IDL = $(ORBIX_BINDIR)/idl +IDLFLAGS = + +# ------------------------------------------------------------ +# The following section defines implicit rules for creating +# *.{C,S}.C files, rules for compiling those +# into objects, and even a rule for compiling C++ source into +# objects (in case one isn't already defined). + +# ------------------------------------------------------------ +# first, put the new suffixes at the *head* of the suffix list, +# overriding any existing .C compilation method. +.SUFFIXES: +.SUFFIXES: .$(C++SUFFIX) .idl $(SUFFIXES) + +# .SUFFIXES: .$(C++SUFFIX) .idl .hh $(SUFFIXES) +# ------------------------------------------------------------ +# *[CS].o must be compiled here, and depends +# mostly on the C++ files produced from the IDL file. + +%C.o: %C.$(C++SUFFIX) + $(C++) -c $(C++FLAGS) $< + +%S.o: %S.$(C++SUFFIX) + $(C++) -c $(C++FLAGS) $< + +%.o: %.$(C++SUFFIX) + $(C++) -c $(C++FLAGS) $< + +# and here's how to compile C++ files from the IDL file. +# only ONE of these rules will be run at make-time, + +%S.$(C++SUFFIX): %.idl + $(IDL) $(IDLFLAGS) $< + +%C.$(C++SUFFIX): %.idl + $(IDL) $(IDLFLAGS) $< + +%.hh: %.idl + $(IDL) $(IDLFLAGS) $< + +# ------------------------------------------------------------ +# If the version of make you wish to use does not support +# pattern matching, here's a sample of an explicit rule set. + +# We assume the IDL file is called "foobar.idl", we wish +# to compile "foobarC.o", "foobarS.o", and +# "foobar.hh", and the C++ file suffix. +# ------------------------------------------------------------ + +# foobarC.o: foobar.hh foobarC.C +# $(C++) -c ($C++FLAGS) foobarC.C +# +# foobarS.o: foobar.hh foobarS.C +# $(C++) -c ($C++FLAGS) foobarS.C +# +# foobarC.C: foobar.idl +# $(IDL) -c ($IDLFLAGS) foobar.idl +# +# foobarS.C: foobar.idl +# $(IDL) -c ($IDLFLAGS) foobar.idl +# +# foobar.hh: foobar.idl +# $(IDL) -c ($IDLFLAGS) foobar.idl diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/Makefile b/TAO/performance-tests/Cubit/Orbix/tpool/Makefile new file mode 100644 index 00000000000..b7703c51956 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/Makefile @@ -0,0 +1,89 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the ACE_MT_CORBA_Handler tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +SRC = cubitS.cpp cubit_impl.cpp server.cpp tpool.cpp + +SVR_OBJS = cubitS.o cubit_impl.o server.o tpool.o + +LDLIBS = + +VLDLIBS = $(LDLIBS:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU +include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#---------------------------------------------------------------------------- +# Orbix related macros and target settings. +#---------------------------------------------------------------------------- + + +ORBIX_BINDIR = $(ORBIX_ROOT)/bin +ORBIX_LIBDIR = $(ORBIX_ROOT)/corba2/lib +ORBIX_INCDIR = $(ORBIX_ROOT)/corba2/include + +# Remove -DCubit_USE_BOA from below to use the TIE approach + +CPPFLAGS += -DEXCEPTIONS -I$(ORBIX_INCDIR) -DWANT_ORBIX_FDS -DCubit_USE_BOA +LDFLAGS += -L$(ORBIX_LIBDIR) -R $(ORBIX_LIBDIR) -L$(ACE)/ace + +IDLFLAGS = -s S.cpp -c C.cpp -B + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +all: server + +server: $(addprefix $(VDIR),$(SVR_OBJS)) + $(LINK.cc) -o server $(addprefix $(VDIR),$(SVR_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITSRV) $(VLDLIBS) $(POSTLINK) + +#---------------------------------------------------------------------------- +# Dependencies +#---------------------------------------------------------------------------- +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubit_impl.o .shobj/cubit_impl.so: cubit_impl.cpp cubit_impl.h cubit.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i +.obj/server.o .shobj/server.so: server.cpp cubit_impl.h cubit.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/cubit.h b/TAO/performance-tests/Cubit/Orbix/tpool/cubit.h new file mode 100644 index 00000000000..1fd0a2d3c7d --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/cubit.h @@ -0,0 +1,729 @@ +// $Id$ + + +#ifndef cubit_hh +#define cubit_hh + +#include "ace/OS.h" +#include <CORBA.h> + + +#ifndef _Cubit_defined +#define _Cubit_defined +class Cubit_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch () {} + + Cubit_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit; + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + + +#ifndef CubitForwH +#define CubitForwH +CORBA::ObjectRef Cubit_getBase (void *); +void Cubit_release (Cubit *, CORBA::Environment &IT_env); +void Cubit_release (Cubit_ptr); +Cubit* Cubit_duplicate (Cubit_ptr, CORBA::Environment &IT_env); +Cubit* Cubit_duplicate (Cubit_ptr ); +Cubit_ptr Cubit_nil (CORBA::Environment &IT_env); +Cubit_ptr Cubit_nil (); +#endif +#define Cubit_IMPL "Cubit" + + +class Cubit; + +typedef Cubit CubitProxy; +#define Cubit_IR "Cubit$v1.1" +#define Cubit_IMPL "Cubit" + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + +class Cubit: public virtual CORBA::Object { +public: + Cubit (char *IT_OR); + Cubit (ObjectReference *IT_OR); + Cubit () : CORBA::Object (1) {} +protected: + Cubit_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_ptr _duplicate( + Cubit_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _bind (CORBA::Environment &IT_env); + static Cubit* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_ptr) CORBA::OBJECT_NIL;} + +#ifndef Cubit_Many_defined +#define Cubit_Many_defined + +struct Many { + CORBA::Octet o; + CORBA::Long l; + CORBA::Short s; + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + Many(const Many &); + Many(); + ~Many(); + Many& operator= (const Many&); +}; + +#ifndef Cubit_ManyVarH +#define Cubit_ManyVarH + +#ifndef Cubit_ManyvPtr +#define Cubit_ManyvPtr +typedef Many* Many_vPtr; +typedef const Many* Many_cvPtr; +#endif + +class Many_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Many_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + Many_var (const Many_var &IT_s) { + (void) copyHelper (IT_s); + } + + Many_var () { + _ptr = new Many; +; + } + + Many_var (Many *IT_p) { + _ptr = IT_p; + } + + Many_var &operator= (Many *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + Many_var &operator= (const Many_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~Many_var () { + delete _ptr; + } + + Many* operator-> () { + return _ptr; + } + + operator Many_cvPtr () const { return _ptr;} + operator Many_vPtr& () { return _ptr;} + operator Many& () const { return * _ptr;} + + protected: + Many *_ptr; + private: + Many_var &operator= (const CORBA::_var &IT_s); + Many_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + +enum discrim {e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th, IT__ENUM_Cubit_discrim=CORBA_ULONG_MAX}; + +#ifndef Cubit_oneof_defined +#define Cubit_oneof_defined + +struct oneof { + private: + + discrim __d; + union { + CORBA::Octet _o_; + CORBA::Short _s_; + CORBA::Long _l_; + Many * _cm_; + }; + + public: + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + + private: + + unsigned char isSet; + + public: + + discrim _d () const { return __d; } + + CORBA::Octet o () const { + return _o_; + } + + void o (CORBA::Octet IT_member) { + if (isSet && (__d != Cubit::e_0th)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_0th; + isSet = 1; + _o_ = IT_member; + } + + CORBA::Short s () const { + return _s_; + } + + void s (CORBA::Short IT_member) { + if (isSet && (__d != Cubit::e_1st)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_1st; + isSet = 1; + _s_ = IT_member; + } + + CORBA::Long l () const { + return _l_; + } + + void l (CORBA::Long IT_member) { + if (isSet && (__d != Cubit::e_2nd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_2nd; + isSet = 1; + _l_ = IT_member; + } + + Many& cm () { + return (*_cm_); + } + + const Many& cm () const { + return (*_cm_); + } + + void cm (const Many& IT_member) { + if (isSet && (__d != Cubit::e_3rd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_3rd; + + if (!isSet) { + _cm_ = new Many; + isSet = 1; + } + *(_cm_) = IT_member; + } + + + oneof(); + oneof(const oneof &); + ~oneof(); + oneof& operator= (const oneof&); +}; + +#ifndef Cubit_oneofVarH +#define Cubit_oneofVarH + +#ifndef Cubit_oneofvPtr +#define Cubit_oneofvPtr +typedef oneof* oneof_vPtr; +typedef const oneof* oneof_cvPtr; +#endif + +class oneof_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const oneof_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + oneof_var (const oneof_var &IT_s) { + (void) copyHelper (IT_s); + } + + oneof_var () { + _ptr = NULL; + } + + oneof_var (oneof *IT_p) { + _ptr = IT_p; + } + + oneof_var &operator= (oneof *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + oneof_var &operator= (const oneof_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~oneof_var () { + delete _ptr; + } + + oneof* operator-> () { + return _ptr; + } + + operator oneof_cvPtr () const { return _ptr;} + operator oneof_vPtr& () { return _ptr;} + operator oneof& () const { return * _ptr;} + + protected: + oneof *_ptr; + private: + oneof_var &operator= (const CORBA::_var &IT_s); + oneof_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef CubitVarH +#define CubitVarH + +#ifndef CubitvPtr +#define CubitvPtr +typedef Cubit* Cubit_vPtr; +typedef const Cubit* Cubit_cvPtr; +#endif + +class Cubit_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_var &IT_s) { + { + _ptr = Cubit_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_var (const Cubit_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_var () { + _ptr = Cubit_nil (); + } + + Cubit_var (Cubit *IT_p) { + _ptr = IT_p; + } + + Cubit_var &operator= (Cubit *IT_p) { + Cubit_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_var &operator= (const Cubit_var &IT_s) { + Cubit_release (_ptr); + _ptr = Cubit_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_var () { + Cubit_release (_ptr); + } + + Cubit* operator-> () { + return _ptr; + } + + operator Cubit_cvPtr () const { return _ptr;} + operator Cubit_vPtr& () { return _ptr;} + + protected: + Cubit *_ptr; + private: + Cubit_var &operator= (const CORBA::_var &IT_s); + Cubit_var (const CORBA::_var &IT_s); + Cubit_var &operator= (const CORBA::_mgr &IT_s); + Cubit_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_var (const CORBA::_mgr &IT_s); + Cubit_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef CubitMgrH +#define CubitMgrH + +class Cubit_mgr : public CORBA::_mgr +{ + public: + + Cubit_mgr () { + _ptr = Cubit_nil (); + _release = 1; + } + + Cubit_mgr (const Cubit_mgr &IT_s) { + _ptr = Cubit_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_mgr &operator= (Cubit *IT_p) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (const Cubit_mgr &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (Cubit_var &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_mgr () { + if (_release) + Cubit_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit* () const { + return (Cubit*) _ptr; + } + + Cubit_ptr operator-> () const { + return _ptr; + } + + Cubit *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_mgr Cubit_mgr_IT_const; +#endif + +#ifndef CubitSeqElemH +#define CubitSeqElemH + +class Cubit_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_SeqElem &operator= (Cubit_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_SeqElem &operator= (const Cubit_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = Cubit_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_ptr () const { + return _ptr ? (Cubit_ptr) (*_ptr) : Cubit_nil(); + } + + Cubit_ptr operator->() const { return *_ptr;} + + protected: + Cubit_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit(X) Cubit##X + +#define DEF_TIE_Cubit(X) \ + class Cubit##X : public virtual Cubit { \ + X* m_obj; \ + public: \ + \ + \ + Cubit##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit(), m_obj(objp) { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,m,l,Cubit_IR,m_obj); \ + } \ + Cubit##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit() { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,IT_m,Cubit_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + + + + +class CubitProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + CubitProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern CubitProxyFactoryClass CubitProxyFactory; + +class CubitBOAImpl : public virtual Cubit { +public: + CubitBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_IR)) + m_pptr = new Cubit_dispatch ( (Cubit*)this, + (CORBA::Object*)this, m, l, Cubit_IR, this); +} + + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/cubit.idl b/TAO/performance-tests/Cubit/Orbix/tpool/cubit.idl new file mode 100644 index 00000000000..d4f1610e2a8 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/cubit.idl @@ -0,0 +1,42 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. + +#pragma prefix "Eng.SUN.COM" +#pragma version Cubit 1.1 + +interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); +}; diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/cubitC.cpp b/TAO/performance-tests/Cubit/Orbix/tpool/cubitC.cpp new file mode 100644 index 00000000000..afd00fd5c23 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/cubitC.cpp @@ -0,0 +1,561 @@ +// $Id$ + +#include "cubit.h" + +ACE_RCSID(tpool, cubitC, "$Id$") + +Cubit::Cubit (char *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} +Cubit::Cubit (ObjectReference *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} + +#ifndef CubitForwC +#define CubitForwC +CORBA::ObjectRef Cubit_getBase(void *IT_p){ + return (Cubit*) IT_p;} + +void Cubit_release (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + CORBA::release(IT_p, IT_env);} + +void Cubit_release (Cubit_ptr IT_p) { + Cubit_release (IT_p, CORBA::IT_chooseDefaultEnv ()); } + +Cubit_ptr Cubit_nil (CORBA::Environment &) { + return Cubit:: _nil ();} + +Cubit_ptr Cubit_nil () { + return Cubit_nil (CORBA::IT_chooseDefaultEnv ());} + +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + return (Cubit::_duplicate(IT_p, IT_env)); } +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p) { + return Cubit_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); } +#endif + +Cubit_ptr Cubit::_duplicate(Cubit_ptr obj, CORBA::Environment& IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (!obj) { + return (obj); + } + Cubit_ptr IT_obj = obj->__duplicate (IT_env); + return IT_obj; +} + + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env) { + return (Cubit*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, + Cubit_IMPL, Cubit_IR); +} + + + +Cubit* Cubit:: _bind (CORBA::Environment &IT_env) { + return _bind (NULL,NULL,CORBA::Context(), IT_env); } + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + CORBA::Environment &IT_env) { + return _bind (IT_markerServer, host, CORBA::Context (), IT_env); } +Cubit* Cubit::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (CORBA::is_nil (IT_obj)) { + return Cubit:: _nil(); + } + + Cubit* IT_p = (Cubit*)CORBA::Object::_castDown (IT_obj, Cubit_IR, IT_env); + IT_p = IT_p ? IT_p->__duplicate(IT_env) : NULL; + if ((IT_env) &&(!strcmp(IT_env.exception()->id(), "CORBA::StExcep::BAD_PARAM")) && (((CORBA::BAD_PARAM*)IT_env.exception())-> minor() == NARROW_FAILED)) { + IT_env.exception_free(); + } + return IT_p; + } + + +#ifndef Cubit_Many_Ops +#define Cubit_Many_Ops + +void Cubit::Many:: encodeOp (CORBA::Request &IT_r) const { + + IT_r.insertOctet (o); + + IT_r << l; + + IT_r << s; +} + +void Cubit::Many:: decodeOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +void Cubit::Many:: decodeInOutOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +Cubit::Many ::~Many () { +} + +Cubit::Many:: Many (const Cubit::Many &IT_s) + { + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; +} + +Cubit::Many:: Many () { +} + +Cubit::Many &Cubit::Many:: operator= (const Cubit::Many& IT_s) { + if (this == &IT_s) return *this; + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; + return *this; +} + + +#endif + + +#ifndef Cubit_oneof_Ops +#define Cubit_oneof_Ops +void Cubit::oneof:: encodeOp (CORBA::Request &IT_r) const { + if (!isSet) return; + { + CORBA::ULong IT_0 = (CORBA::ULong) __d; + IT_r << IT_0; + } + switch (__d) { + case Cubit::e_0th: + IT_r.insertOctet (_o_); + break; + case Cubit::e_1st: + IT_r << _s_; + break; + case Cubit::e_2nd: + IT_r << _l_; + break; + case Cubit::e_3rd: + default: + (*_cm_).encodeOp (IT_r); + break; + } + +} + +void Cubit::oneof:: decodeOp (CORBA::Request &IT_r) { + isSet = 0; + { + CORBA::ULong IT_1; + IT_r >> IT_1; + __d = Cubit::discrim(IT_1); + } + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + +} +void Cubit::oneof:: decodeInOutOp (CORBA::Request &IT_r) { + Cubit::discrim IT_d; + { + CORBA::ULong IT_2; + IT_r >> IT_2; + IT_d = Cubit::discrim(IT_2); + } + if (IT_d == __d) + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeInOutOp (IT_r); + break; + } + + else { + this->oneof:: ~oneof(); + memset(this, 0, sizeof(*this)); + __d = IT_d; + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + isSet = 1; + } + +} + +Cubit::oneof:: oneof() { + memset(this, 0, sizeof(*this)); + isSet = 0; +} + +Cubit::oneof ::~oneof() { + if (!isSet) return; + switch (__d) { + case Cubit::e_0th: break; + case Cubit::e_1st: break; + case Cubit::e_2nd: break; + case Cubit::e_3rd: + default: if (_cm_) delete _cm_; + break; + } + + isSet = 0; +} + +Cubit::oneof:: oneof (const Cubit::oneof &IT_s) { + isSet = 0; + memset(this, 0, sizeof(*this)); + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; +} + +Cubit::oneof& Cubit::oneof:: operator= (const Cubit::oneof & IT_s) { + if (this == &IT_s) return *this; + if (isSet && (__d != IT_s.__d)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; + return *this; +} + + +#endif + +void* CubitProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New2 () { + return new class Cubit((char*)0);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::New2Object () { + return new class Cubit((char*)0);} + +void* CubitProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env) { + void *IT_l; + if (!CORBA::_interfaceCmp (IT_s,Cubit_IR, IT_env)) + return IT_p; + else if (IT_l=CORBA::ObjectFactoryClass::IT_castUp((CORBA::Object*)((class Cubit*)IT_p),IT_s, IT_env)) + return IT_l; + else return NULL; + } + + +CORBA::PPTR* CubitProxyFactoryClass::pptr (void *IT_p) { + return ((class Cubit*)IT_p)->_pptr ();} + +void CubitProxyFactoryClass::baseInterfaces (_IDL_SEQUENCE_string& seq) { + add (seq, Cubit_IR); + CORBA::ObjectFactoryClass::baseInterfaces (seq); +} + +CubitProxyFactoryClass CubitProxyFactory(1); + +CORBA::Octet Cubit:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_octet",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r.insertOctet (o); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Octet IT_result; + IT_r.extractOctet (IT_result); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Short Cubit:: cube_short (CORBA::Short s, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_short",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << s; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Short IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Long Cubit:: cube_long (CORBA::Long l, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_long",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << l; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Long IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +Cubit::Many Cubit:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::Many IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_struct",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::Many IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::Many IT_l1; + return IT_l1; + } +} + +Cubit::oneof Cubit:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::oneof IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_union",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::oneof IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::oneof IT_l1; + return IT_l1; + } +} + +void Cubit:: please_exit (CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return ; + } + CORBA::Request IT_r (this, "please_exit",IT_env,1,1); + + IT_r.invoke (CORBA::Flags(CORBA::INV_NO_RESPONSE), IT_env); + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } +} + + + + + +#ifndef Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char, void *) { + IT_r.makeRuntimeException1 ("Cubit"); + return 0; +} + +#endif + diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/cubitS.cpp b/TAO/performance-tests/Cubit/Orbix/tpool/cubitS.cpp new file mode 100644 index 00000000000..bfa6c30e86d --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/cubitS.cpp @@ -0,0 +1,230 @@ +// $Id$ + +#include "cubit.h" + + +ACE_RCSID(tpool, cubitS, "$Id$") + +#define Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void *IT_pp) { + if (!IT_pp) + IT_pp = m_obj; + const char *IT_s = IT_r.getOperation (); + if (!strcmp(IT_s,"cube_octet")) { + CORBA::Octet IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_octet~+o{o},>{o},N{}\ +")) + return 1; + CORBA::Octet o; + + IT_r.extractOctet (o); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_octet ( o, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +o\ +", IT_env)) return 1; + IT_r.insertOctet (IT_result); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_short")) { + CORBA::Short IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_short~+s{s},>{s},N{}\ +")) + return 1; + CORBA::Short s; + + IT_r >> s; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_short ( s, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +s\ +", IT_env)) return 1; + IT_r << IT_result; + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_long")) { + CORBA::Long IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_long~+l{l},>{l},N{}\ +")) + return 1; + CORBA::Long l; + + IT_r >> l; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_long ( l, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +l\ +", IT_env)) return 1; + IT_r << IT_result; + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_struct")) { + Cubit::Many IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_struct~+values{R~Cubit::Many~o{o},l{l},s{s}},>{R~Cubit::Many~o{o},l{l},s{s}},N{}\ +")) + return 1; + Cubit::Many values; + + values.decodeOp (IT_r); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_struct ( values, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +R~Cubit::Many~o{o},l{l},s{s}\ +", IT_env)) return 1; + IT_result.encodeOp (IT_r); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_union")) { + Cubit::oneof IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + IT_r.tcPreAssert ( +"\ +Ro~cube_union~+values{U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}},>{U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,\ +"); + if (!IT_r.tcAssert ("\ +e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}},N{}\ +")) + return 1; + Cubit::oneof values; + + values.decodeOp (IT_r); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_union ( values, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}\ +", IT_env)) return 1; + IT_result.encodeOp (IT_r); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"please_exit")) { + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~please_exit~>{v},O{}\ +")) + return 1; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + ((Cubit*)IT_pp)->please_exit (IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env); + return 1; + } + + if (IT_isTarget) + IT_r.makeRuntimeException2 (); + + return 0; +} + +#include "cubitC.cpp" + diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/cubit_impl.cpp b/TAO/performance-tests/Cubit/Orbix/tpool/cubit_impl.cpp new file mode 100644 index 00000000000..e1ed154b9f6 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/cubit_impl.cpp @@ -0,0 +1,50 @@ +// $Id$ + +#include "cubit_impl.h" + +ACE_RCSID(tpool, cubit_impl, "$Id$") + +CORBA::Octet Cubit_Impl:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Octet) (o * o * o); +} + +CORBA::Short Cubit_Impl:: cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Short) (s * s * s); +} + +CORBA::Long Cubit_Impl:: cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Long) (l * l * l); +} + +Cubit::Many Cubit_Impl:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + Cubit::Many out_values; + out_values.o = values.o * values.o * values.o; + out_values.s = values.s * values.s * values.s; + out_values.l = values.l * values.l * values.l; + return out_values; +} + +Cubit::oneof Cubit_Impl:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + Cubit::oneof out_values; + switch (values._d ()) { + case Cubit::e_0th: + out_values.o (values.o () * values.o () * values.o ()); + break; + case Cubit::e_1st: + out_values.s (values.s () * values.s () * values.s ()); + break; + case Cubit::e_2nd: + out_values.l (values.l () * values.l () * values.l ()); + break; + case Cubit::e_3rd: + default: + out_values.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o ; + out_values.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s ; + out_values.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l ; + break; + } + return out_values; +} + +void Cubit_Impl:: please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException) { +} diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/cubit_impl.h b/TAO/performance-tests/Cubit/Orbix/tpool/cubit_impl.h new file mode 100644 index 00000000000..033aa7f0cb1 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/cubit_impl.h @@ -0,0 +1,29 @@ +// $Id$ + + +#ifndef cubit_ih +#define cubit_ih + +#include "cubit.h" + + +#ifdef Cubit_USE_BOA +class Cubit_Impl : public virtual CubitBOAImpl { +#else +class Cubit_Impl { +#endif /* Cubit_USE_BOA */ + +public: + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); +}; + +#ifndef Cubit_USE_BOA +DEF_TIE_Cubit (Cubit_Impl) +#endif /* Cubit_USE_BOA */ + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/server.cpp b/TAO/performance-tests/Cubit/Orbix/tpool/server.cpp new file mode 100644 index 00000000000..fd486ba5d6f --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/server.cpp @@ -0,0 +1,50 @@ +// $Id$ + +//************************************************************************** +// +// NAME : tpr_server.cpp +// DESCRIPTION: +// +// Server mainline +// +//**************************************************************************** +#define IT_EX_MACROS + +#include "cubit_impl.h" // server header file +#include "tpool.h" + +ACE_RCSID(tpool, server, "$Id$") + +int +main (int argc, char** argv) +{ + + +#ifdef Cubit_USE_BOA + Cubit_var cb = new Cubit_Impl; + cout << "Using BOA approach" << endl; +#else + Cubit_var cb = new TIE_Cubit (Cubit_Impl) (new Cubit_Impl); + cout << "Using TIE approach" << endl; +#endif /* Cubit_USE_BOA */ + + // Register our thread-pool dispatcher + int n_threads = argc > 1 ? ACE_OS::atoi (argv[1]) : ACE_DEFAULT_THREADS; + Thread_Pool tpool_dispatcher (n_threads); + + // + // Go get some work to do.... + // + IT_TRY { + CORBA::Orbix.impl_is_ready("Cubit", IT_X); + } + IT_CATCHANY { + cout << IT_X << endl; + } + IT_ENDTRY; + + cout << "Cubit server is exiting." << endl; + + + return 0; +} diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/tpool.cpp b/TAO/performance-tests/Cubit/Orbix/tpool/tpool.cpp new file mode 100644 index 00000000000..008f777cb22 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/tpool.cpp @@ -0,0 +1,46 @@ +// $Id$ + +#include "tpool.h" + +ACE_RCSID(tpool, tpool, "$Id$") + +Thread_Pool::Thread_Pool (int n_threads) + : ACE_Task<ACE_MT_SYNCH> (ACE_Thread_Manager::instance ()) +{ + if (this->activate (THR_DETACHED | THR_NEW_LWP, n_threads) == -1) + ACE_ERROR ((LM_ERROR, "%p\n", "activate failed")); +} + +int +Thread_Pool::svc (void) +{ + cout << "Pool thread activated" << endl; + while (1) + { + // Dequeue message + ACE_Message_Block *mb; + this->msg_queue ()->dequeue_head (mb); + CORBA::Request *vp = (CORBA::Request *) mb->base (); + mb->release (); + // Hand it off to Orbix + CORBA::Orbix.continueThreadDispatch (*vp); + } + return -1; +} + + +int +Thread_Pool::inRequestPreMarshal(CORBA::Request &r, CORBA::Environment&) +{ +// thread_t tid; +// thr_create(NULL, 0, worker, (void *)&r, THR_DETACHED, &tid); + + // Enqueue the request + ACE_Message_Block *mb = new ACE_Message_Block ( (char *) (&r)); + this->msg_queue ()->enqueue (mb); + // Done + return -1; +} + + + diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/tpool.h b/TAO/performance-tests/Cubit/Orbix/tpool/tpool.h new file mode 100644 index 00000000000..337a7f54e65 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpool/tpool.h @@ -0,0 +1,17 @@ +// $Id$ + +#include "cubit.h" +#include "ace/Service_Config.h" +#include "ace/Thread_Manager.h" +#include "ace/Task.h" + +class Thread_Pool : public ACE_Task<ACE_MT_SYNCH>, public CORBA::ThreadFilter +{ +public: + Thread_Pool (int n_threads); + virtual int inRequestPreMarshal(CORBA::Request &, CORBA::Environment&); + virtual int svc (void); + +}; + + diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/Makefile b/TAO/performance-tests/Cubit/Orbix/tpr/Makefile new file mode 100644 index 00000000000..74a5517d664 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/Makefile @@ -0,0 +1,89 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the ACE_MT_CORBA_Handler tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +SRC = cubitS.cpp cubit_impl.cpp server.cpp tpr.cpp + +SVR_OBJS = cubitS.o cubit_impl.o server.o tpr.o + +LDLIBS = + +VLDLIBS = $(LDLIBS:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU +include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#---------------------------------------------------------------------------- +# Orbix related macros and target settings. +#---------------------------------------------------------------------------- + + +ORBIX_BINDIR = $(ORBIX_ROOT)/bin +ORBIX_LIBDIR = $(ORBIX_ROOT)/corba2/lib +ORBIX_INCDIR = $(ORBIX_ROOT)/corba2/include + +# Remove -DCubit_USE_BOA from below to use the TIE approach + +CPPFLAGS += -DEXCEPTIONS -I$(ORBIX_INCDIR) -DWANT_ORBIX_FDS -DCubit_USE_BOA +LDFLAGS += -L$(ORBIX_LIBDIR) -R $(ORBIX_LIBDIR) -L$(ACE)/ace + +IDLFLAGS = -s S.cpp -c C.cpp -B + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +all: server + +server: $(addprefix $(VDIR),$(SVR_OBJS)) + $(LINK.cc) -o server $(addprefix $(VDIR),$(SVR_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITSRV) $(VLDLIBS) $(POSTLINK) + +#---------------------------------------------------------------------------- +# Dependencies +#---------------------------------------------------------------------------- +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubit_impl.o .shobj/cubit_impl.so: cubit_impl.cpp cubit_impl.h cubit.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i +.obj/server.o .shobj/server.so: server.cpp cubit_impl.h cubit.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/cubit.h b/TAO/performance-tests/Cubit/Orbix/tpr/cubit.h new file mode 100644 index 00000000000..1fd0a2d3c7d --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/cubit.h @@ -0,0 +1,729 @@ +// $Id$ + + +#ifndef cubit_hh +#define cubit_hh + +#include "ace/OS.h" +#include <CORBA.h> + + +#ifndef _Cubit_defined +#define _Cubit_defined +class Cubit_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch () {} + + Cubit_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit; + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + + +#ifndef CubitForwH +#define CubitForwH +CORBA::ObjectRef Cubit_getBase (void *); +void Cubit_release (Cubit *, CORBA::Environment &IT_env); +void Cubit_release (Cubit_ptr); +Cubit* Cubit_duplicate (Cubit_ptr, CORBA::Environment &IT_env); +Cubit* Cubit_duplicate (Cubit_ptr ); +Cubit_ptr Cubit_nil (CORBA::Environment &IT_env); +Cubit_ptr Cubit_nil (); +#endif +#define Cubit_IMPL "Cubit" + + +class Cubit; + +typedef Cubit CubitProxy; +#define Cubit_IR "Cubit$v1.1" +#define Cubit_IMPL "Cubit" + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + +class Cubit: public virtual CORBA::Object { +public: + Cubit (char *IT_OR); + Cubit (ObjectReference *IT_OR); + Cubit () : CORBA::Object (1) {} +protected: + Cubit_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_ptr _duplicate( + Cubit_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _bind (CORBA::Environment &IT_env); + static Cubit* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_ptr) CORBA::OBJECT_NIL;} + +#ifndef Cubit_Many_defined +#define Cubit_Many_defined + +struct Many { + CORBA::Octet o; + CORBA::Long l; + CORBA::Short s; + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + Many(const Many &); + Many(); + ~Many(); + Many& operator= (const Many&); +}; + +#ifndef Cubit_ManyVarH +#define Cubit_ManyVarH + +#ifndef Cubit_ManyvPtr +#define Cubit_ManyvPtr +typedef Many* Many_vPtr; +typedef const Many* Many_cvPtr; +#endif + +class Many_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Many_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + Many_var (const Many_var &IT_s) { + (void) copyHelper (IT_s); + } + + Many_var () { + _ptr = new Many; +; + } + + Many_var (Many *IT_p) { + _ptr = IT_p; + } + + Many_var &operator= (Many *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + Many_var &operator= (const Many_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~Many_var () { + delete _ptr; + } + + Many* operator-> () { + return _ptr; + } + + operator Many_cvPtr () const { return _ptr;} + operator Many_vPtr& () { return _ptr;} + operator Many& () const { return * _ptr;} + + protected: + Many *_ptr; + private: + Many_var &operator= (const CORBA::_var &IT_s); + Many_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + +enum discrim {e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th, IT__ENUM_Cubit_discrim=CORBA_ULONG_MAX}; + +#ifndef Cubit_oneof_defined +#define Cubit_oneof_defined + +struct oneof { + private: + + discrim __d; + union { + CORBA::Octet _o_; + CORBA::Short _s_; + CORBA::Long _l_; + Many * _cm_; + }; + + public: + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + + private: + + unsigned char isSet; + + public: + + discrim _d () const { return __d; } + + CORBA::Octet o () const { + return _o_; + } + + void o (CORBA::Octet IT_member) { + if (isSet && (__d != Cubit::e_0th)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_0th; + isSet = 1; + _o_ = IT_member; + } + + CORBA::Short s () const { + return _s_; + } + + void s (CORBA::Short IT_member) { + if (isSet && (__d != Cubit::e_1st)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_1st; + isSet = 1; + _s_ = IT_member; + } + + CORBA::Long l () const { + return _l_; + } + + void l (CORBA::Long IT_member) { + if (isSet && (__d != Cubit::e_2nd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_2nd; + isSet = 1; + _l_ = IT_member; + } + + Many& cm () { + return (*_cm_); + } + + const Many& cm () const { + return (*_cm_); + } + + void cm (const Many& IT_member) { + if (isSet && (__d != Cubit::e_3rd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_3rd; + + if (!isSet) { + _cm_ = new Many; + isSet = 1; + } + *(_cm_) = IT_member; + } + + + oneof(); + oneof(const oneof &); + ~oneof(); + oneof& operator= (const oneof&); +}; + +#ifndef Cubit_oneofVarH +#define Cubit_oneofVarH + +#ifndef Cubit_oneofvPtr +#define Cubit_oneofvPtr +typedef oneof* oneof_vPtr; +typedef const oneof* oneof_cvPtr; +#endif + +class oneof_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const oneof_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + oneof_var (const oneof_var &IT_s) { + (void) copyHelper (IT_s); + } + + oneof_var () { + _ptr = NULL; + } + + oneof_var (oneof *IT_p) { + _ptr = IT_p; + } + + oneof_var &operator= (oneof *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + oneof_var &operator= (const oneof_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~oneof_var () { + delete _ptr; + } + + oneof* operator-> () { + return _ptr; + } + + operator oneof_cvPtr () const { return _ptr;} + operator oneof_vPtr& () { return _ptr;} + operator oneof& () const { return * _ptr;} + + protected: + oneof *_ptr; + private: + oneof_var &operator= (const CORBA::_var &IT_s); + oneof_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef CubitVarH +#define CubitVarH + +#ifndef CubitvPtr +#define CubitvPtr +typedef Cubit* Cubit_vPtr; +typedef const Cubit* Cubit_cvPtr; +#endif + +class Cubit_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_var &IT_s) { + { + _ptr = Cubit_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_var (const Cubit_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_var () { + _ptr = Cubit_nil (); + } + + Cubit_var (Cubit *IT_p) { + _ptr = IT_p; + } + + Cubit_var &operator= (Cubit *IT_p) { + Cubit_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_var &operator= (const Cubit_var &IT_s) { + Cubit_release (_ptr); + _ptr = Cubit_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_var () { + Cubit_release (_ptr); + } + + Cubit* operator-> () { + return _ptr; + } + + operator Cubit_cvPtr () const { return _ptr;} + operator Cubit_vPtr& () { return _ptr;} + + protected: + Cubit *_ptr; + private: + Cubit_var &operator= (const CORBA::_var &IT_s); + Cubit_var (const CORBA::_var &IT_s); + Cubit_var &operator= (const CORBA::_mgr &IT_s); + Cubit_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_var (const CORBA::_mgr &IT_s); + Cubit_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef CubitMgrH +#define CubitMgrH + +class Cubit_mgr : public CORBA::_mgr +{ + public: + + Cubit_mgr () { + _ptr = Cubit_nil (); + _release = 1; + } + + Cubit_mgr (const Cubit_mgr &IT_s) { + _ptr = Cubit_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_mgr &operator= (Cubit *IT_p) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (const Cubit_mgr &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (Cubit_var &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_mgr () { + if (_release) + Cubit_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit* () const { + return (Cubit*) _ptr; + } + + Cubit_ptr operator-> () const { + return _ptr; + } + + Cubit *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_mgr Cubit_mgr_IT_const; +#endif + +#ifndef CubitSeqElemH +#define CubitSeqElemH + +class Cubit_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_SeqElem &operator= (Cubit_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_SeqElem &operator= (const Cubit_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = Cubit_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_ptr () const { + return _ptr ? (Cubit_ptr) (*_ptr) : Cubit_nil(); + } + + Cubit_ptr operator->() const { return *_ptr;} + + protected: + Cubit_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit(X) Cubit##X + +#define DEF_TIE_Cubit(X) \ + class Cubit##X : public virtual Cubit { \ + X* m_obj; \ + public: \ + \ + \ + Cubit##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit(), m_obj(objp) { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,m,l,Cubit_IR,m_obj); \ + } \ + Cubit##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit() { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,IT_m,Cubit_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + + + + +class CubitProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + CubitProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern CubitProxyFactoryClass CubitProxyFactory; + +class CubitBOAImpl : public virtual Cubit { +public: + CubitBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_IR)) + m_pptr = new Cubit_dispatch ( (Cubit*)this, + (CORBA::Object*)this, m, l, Cubit_IR, this); +} + + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/cubit.idl b/TAO/performance-tests/Cubit/Orbix/tpr/cubit.idl new file mode 100644 index 00000000000..d4f1610e2a8 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/cubit.idl @@ -0,0 +1,42 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. + +#pragma prefix "Eng.SUN.COM" +#pragma version Cubit 1.1 + +interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); +}; diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/cubitC.cpp b/TAO/performance-tests/Cubit/Orbix/tpr/cubitC.cpp new file mode 100644 index 00000000000..4bc7a548c54 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/cubitC.cpp @@ -0,0 +1,561 @@ +// $Id$ + +#include "cubit.h" + +ACE_RCSID(tpr, cubitC, "$Id$") + +Cubit::Cubit (char *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} +Cubit::Cubit (ObjectReference *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} + +#ifndef CubitForwC +#define CubitForwC +CORBA::ObjectRef Cubit_getBase(void *IT_p){ + return (Cubit*) IT_p;} + +void Cubit_release (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + CORBA::release(IT_p, IT_env);} + +void Cubit_release (Cubit_ptr IT_p) { + Cubit_release (IT_p, CORBA::IT_chooseDefaultEnv ()); } + +Cubit_ptr Cubit_nil (CORBA::Environment &) { + return Cubit:: _nil ();} + +Cubit_ptr Cubit_nil () { + return Cubit_nil (CORBA::IT_chooseDefaultEnv ());} + +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + return (Cubit::_duplicate(IT_p, IT_env)); } +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p) { + return Cubit_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); } +#endif + +Cubit_ptr Cubit::_duplicate(Cubit_ptr obj, CORBA::Environment& IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (!obj) { + return (obj); + } + Cubit_ptr IT_obj = obj->__duplicate (IT_env); + return IT_obj; +} + + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env) { + return (Cubit*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, + Cubit_IMPL, Cubit_IR); +} + + + +Cubit* Cubit:: _bind (CORBA::Environment &IT_env) { + return _bind (NULL,NULL,CORBA::Context(), IT_env); } + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + CORBA::Environment &IT_env) { + return _bind (IT_markerServer, host, CORBA::Context (), IT_env); } +Cubit* Cubit::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (CORBA::is_nil (IT_obj)) { + return Cubit:: _nil(); + } + + Cubit* IT_p = (Cubit*)CORBA::Object::_castDown (IT_obj, Cubit_IR, IT_env); + IT_p = IT_p ? IT_p->__duplicate(IT_env) : NULL; + if ((IT_env) &&(!strcmp(IT_env.exception()->id(), "CORBA::StExcep::BAD_PARAM")) && (((CORBA::BAD_PARAM*)IT_env.exception())-> minor() == NARROW_FAILED)) { + IT_env.exception_free(); + } + return IT_p; + } + + +#ifndef Cubit_Many_Ops +#define Cubit_Many_Ops + +void Cubit::Many:: encodeOp (CORBA::Request &IT_r) const { + + IT_r.insertOctet (o); + + IT_r << l; + + IT_r << s; +} + +void Cubit::Many:: decodeOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +void Cubit::Many:: decodeInOutOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +Cubit::Many ::~Many () { +} + +Cubit::Many:: Many (const Cubit::Many &IT_s) + { + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; +} + +Cubit::Many:: Many () { +} + +Cubit::Many &Cubit::Many:: operator= (const Cubit::Many& IT_s) { + if (this == &IT_s) return *this; + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; + return *this; +} + + +#endif + + +#ifndef Cubit_oneof_Ops +#define Cubit_oneof_Ops +void Cubit::oneof:: encodeOp (CORBA::Request &IT_r) const { + if (!isSet) return; + { + CORBA::ULong IT_0 = (CORBA::ULong) __d; + IT_r << IT_0; + } + switch (__d) { + case Cubit::e_0th: + IT_r.insertOctet (_o_); + break; + case Cubit::e_1st: + IT_r << _s_; + break; + case Cubit::e_2nd: + IT_r << _l_; + break; + case Cubit::e_3rd: + default: + (*_cm_).encodeOp (IT_r); + break; + } + +} + +void Cubit::oneof:: decodeOp (CORBA::Request &IT_r) { + isSet = 0; + { + CORBA::ULong IT_1; + IT_r >> IT_1; + __d = Cubit::discrim(IT_1); + } + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + +} +void Cubit::oneof:: decodeInOutOp (CORBA::Request &IT_r) { + Cubit::discrim IT_d; + { + CORBA::ULong IT_2; + IT_r >> IT_2; + IT_d = Cubit::discrim(IT_2); + } + if (IT_d == __d) + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeInOutOp (IT_r); + break; + } + + else { + this->oneof:: ~oneof(); + memset(this, 0, sizeof(*this)); + __d = IT_d; + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + isSet = 1; + } + +} + +Cubit::oneof:: oneof() { + memset(this, 0, sizeof(*this)); + isSet = 0; +} + +Cubit::oneof ::~oneof() { + if (!isSet) return; + switch (__d) { + case Cubit::e_0th: break; + case Cubit::e_1st: break; + case Cubit::e_2nd: break; + case Cubit::e_3rd: + default: if (_cm_) delete _cm_; + break; + } + + isSet = 0; +} + +Cubit::oneof:: oneof (const Cubit::oneof &IT_s) { + isSet = 0; + memset(this, 0, sizeof(*this)); + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; +} + +Cubit::oneof& Cubit::oneof:: operator= (const Cubit::oneof & IT_s) { + if (this == &IT_s) return *this; + if (isSet && (__d != IT_s.__d)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; + return *this; +} + + +#endif + +void* CubitProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New2 () { + return new class Cubit((char*)0);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::New2Object () { + return new class Cubit((char*)0);} + +void* CubitProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env) { + void *IT_l; + if (!CORBA::_interfaceCmp (IT_s,Cubit_IR, IT_env)) + return IT_p; + else if (IT_l=CORBA::ObjectFactoryClass::IT_castUp((CORBA::Object*)((class Cubit*)IT_p),IT_s, IT_env)) + return IT_l; + else return NULL; + } + + +CORBA::PPTR* CubitProxyFactoryClass::pptr (void *IT_p) { + return ((class Cubit*)IT_p)->_pptr ();} + +void CubitProxyFactoryClass::baseInterfaces (_IDL_SEQUENCE_string& seq) { + add (seq, Cubit_IR); + CORBA::ObjectFactoryClass::baseInterfaces (seq); +} + +CubitProxyFactoryClass CubitProxyFactory(1); + +CORBA::Octet Cubit:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_octet",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r.insertOctet (o); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Octet IT_result; + IT_r.extractOctet (IT_result); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Short Cubit:: cube_short (CORBA::Short s, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_short",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << s; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Short IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Long Cubit:: cube_long (CORBA::Long l, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_long",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << l; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Long IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +Cubit::Many Cubit:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::Many IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_struct",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::Many IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::Many IT_l1; + return IT_l1; + } +} + +Cubit::oneof Cubit:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::oneof IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_union",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::oneof IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::oneof IT_l1; + return IT_l1; + } +} + +void Cubit:: please_exit (CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return ; + } + CORBA::Request IT_r (this, "please_exit",IT_env,1,1); + + IT_r.invoke (CORBA::Flags(CORBA::INV_NO_RESPONSE), IT_env); + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } +} + + + + + +#ifndef Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char, void *) { + IT_r.makeRuntimeException1 ("Cubit"); + return 0; +} + +#endif + diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/cubitC.h b/TAO/performance-tests/Cubit/Orbix/tpr/cubitC.h new file mode 100644 index 00000000000..584efa67c8d --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/cubitC.h @@ -0,0 +1,345 @@ +// $Id$ + +#ifndef _cubitC_h +#define _cubitC_h + +/************************************************************************/ +/* */ +/* This file is automatically generated by ORBeline IDL compiler */ +/* Do not modify this file. */ +/* */ +/* ORBeline (c) is copyrighted by PostModern Computing, Inc. */ +/* */ +/* The generated code conforms to OMG's IDL C++ mapping as */ +/* specified in OMG Document Number: 94-9-14. */ +/* */ +/************************************************************************/ + +#include "corba.h" + + + +class Cubit; +typedef Cubit *Cubit_ptr; +typedef Cubit_ptr CubitRef; + +#ifndef _Cubit_var_ +#define _Cubit_var_ +class Cubit_var +{ + public: + Cubit_var(); + Cubit_var(Cubit_ptr); + Cubit_var(const Cubit_var&); + ~Cubit_var(); + Cubit_var& operator=(Cubit_ptr); + operator Cubit_ptr() const { return _ptr; } +#if defined(_HPCC_BUG) + operator Cubit *&() { return _ptr; } +#else + operator Cubit_ptr&() { return _ptr; } +#endif + Cubit_ptr operator->() const { return _ptr;} + friend NCistream& operator>>(NCistream&, Cubit_var&); + friend NCostream& operator<<(NCostream&, const Cubit_var&); + friend istream& operator>>(istream&, Cubit_var&); + friend ostream& operator<<(ostream&, const Cubit_var&); + private: + Cubit_ptr _ptr; + void operator=(const Cubit_var&) {} +}; +#endif +class Cubit: public virtual CORBA_Object +{ + private: + static const CORBA::TypeInfo _class_info; + Cubit(const Cubit&) {} + void operator=(const Cubit&){} + public: + static const CORBA::TypeInfo *_desc(); + virtual const CORBA::TypeInfo *_type_info() const; + virtual void *_safe_narrow(const CORBA::TypeInfo& ) const; + static CORBA::Object *_factory(); + protected: + Cubit(const char *obj_name = NULL) :CORBA_Object(obj_name, 1) {} + Cubit(NCistream& strm) :CORBA_Object(strm) {} + virtual ~Cubit() {} + public: + static Cubit_ptr _duplicate(Cubit_ptr obj) { + if (obj ) obj->_ref(); + return obj; + } + static Cubit_ptr _nil() { return (Cubit_ptr)NULL;} + static Cubit_ptr _narrow(CORBA::Object *obj); + static Cubit_ptr _clone(Cubit_ptr obj) { + CORBA::Object_var obj_var(__clone(obj)); + +#if defined(_HPCC_BUG) + return _narrow(obj_var.operator CORBA::Object_ptr()); +#else + return _narrow(obj_var); +#endif + } + static Cubit_ptr _bind(const char *object_name = NULL, + const char *host_name = NULL, + const CORBA::BindOptions* opt = NULL); + + virtual CORBA::Octet cube_octet(CORBA::Octet o); + + virtual CORBA::Short cube_short(CORBA::Short s); + + virtual CORBA::Long cube_long(CORBA::Long l); + + struct Many { + CORBA::Octet o; + CORBA::Long l; + CORBA::Short s; + }; + friend NCostream& operator<<(NCostream&, const Many& ); + friend NCistream& operator>>(NCistream&, Many& ); + + friend ostream& operator<<(ostream&, const Many& ); + inline friend istream& operator>>(istream& _strm, Many& _obj) { + NCistream _istrm(_strm); + _istrm >> _obj; + return _strm; + } + + + typedef Many *Many_ptr; + class Many_var + { + public: + Many_var() { _ptr = (Many*)NULL;} + Many_var(Many *ptr) { + _ptr = ptr; + } + Many_var(const Many_var& var) { + if (var._ptr) + _ptr = new Many(*var._ptr); + else + _ptr = (Many *)NULL; + } + ~Many_var() { + if (_ptr != (Many *)NULL) delete _ptr; + } + Many_var& operator=(Many *ptr) { + if (_ptr != (Many *)NULL) delete _ptr; + _ptr = ptr; + return *this; + } + Many_var& operator=(const Many_var& var) { + if (_ptr != (Many *)NULL) delete _ptr; + if (var._ptr) + _ptr = new Many(*var._ptr); + else + _ptr = (Many *)NULL; + return *this; + } + Many *operator->() { return _ptr; } + operator Many () const { return *_ptr; } + operator Many& () { return *_ptr; } + inline friend NCostream& operator<<(NCostream& strm, + const Many_var& var) { + if (var._ptr == (Many *)NULL) { + throw CORBA::BAD_PARAM(); + } + else + strm << *var._ptr; + return strm; + } + inline friend NCistream& operator>>(NCistream& strm, + Many_var& var) { + if ( ! var._ptr) + var._ptr = new Many; + strm >> *var._ptr; + return strm; + } + private: + Many *_ptr; + }; + + + virtual Cubit::Many cube_struct(const Cubit::Many& values); + + enum discrim { + e_0th, + e_1st, + e_2nd, + e_3rd, + e_4th, + e_5th + }; + inline friend NCostream& operator<<(NCostream& _strm, discrim _enum_type) { + _strm << (CORBA::ULong)_enum_type; + return _strm; + } + inline friend NCistream& operator>>(NCistream& _strm, discrim& _enum_type) { + CORBA::ULong _temp; + _strm >> _temp; + if (_temp >= 6) + throw CORBA::BAD_PARAM(); + _enum_type = discrim(_temp); + return _strm; + } + inline friend ostream& operator<<(ostream& _strm, discrim _enum_type) { + if( &_strm == &cout || &_strm == &cerr || &_strm == &clog) { + _strm << "discrim:"; + switch(_enum_type) { + case e_0th: + _strm << "e_0th" << endl; + break; + case e_1st: + _strm << "e_1st" << endl; + break; + case e_2nd: + _strm << "e_2nd" << endl; + break; + case e_3rd: + _strm << "e_3rd" << endl; + break; + case e_4th: + _strm << "e_4th" << endl; + break; + case e_5th: + _strm << "e_5th" << endl; + break; + } + } + else + _strm << (CORBA::ULong)_enum_type; + return _strm; + } + inline friend istream& operator>>(istream& _strm, discrim& _enum_type) { + CORBA::ULong _temp; + _strm >> _temp; + _enum_type = discrim(_temp); + return _strm; + } + + + class oneof + { + public: + private: + discrim _disc; + CORBA::Octet __o; + CORBA::Short __s; + CORBA::Long __l; + Cubit::Many __cm; + public: + oneof() : _disc(discrim(0)) {} + ~oneof() {} + oneof(const oneof& obj); + oneof& operator=(const oneof& obj); + + void _d(discrim val) { _disc = val; } + discrim _d() const { return _disc; } + + void o(CORBA::Octet val) { + __o = val; + _disc = Cubit::e_0th; + } + CORBA::Octet o() const { return __o; } + + void s(CORBA::Short val) { + __s = val; + _disc = Cubit::e_1st; + } + CORBA::Short s() const { return __s; } + + void l(CORBA::Long val) { + __l = val; + _disc = Cubit::e_2nd; + } + CORBA::Long l() const { return __l; } + + void cm(const Cubit::Many& val) { + __cm = val; + _disc = Cubit::e_3rd; + } + const Cubit::Many& cm() const { return __cm; } + Cubit::Many& cm() { return __cm; } + + friend NCostream& operator<<(NCostream&, const oneof& ); + friend NCistream& operator>>(NCistream&, oneof& ); + friend ostream& operator<<(ostream&, const oneof&); + inline friend istream& operator>>(istream& strm, oneof& obj) { + NCistream istrm(strm); + strm >> obj; + return strm; + } + }; + + typedef oneof *oneof_ptr; + class oneof_var + { + public: + oneof_var() { _ptr = (oneof*)NULL;} + oneof_var(oneof *ptr) { + _ptr = ptr; + } + oneof_var(const oneof_var& var) { + _ptr = new oneof(*var._ptr); + } + ~oneof_var() { + if (_ptr != (oneof *)NULL) delete _ptr; + } + oneof_var& operator=(oneof *ptr) { + if (_ptr != (oneof *)NULL) delete _ptr; + _ptr = ptr; + return *this; + } + oneof_var& operator=(const oneof_var& var) { + if (_ptr != (oneof *)NULL) delete _ptr; + _ptr = new oneof(*var._ptr); + return *this; + } + oneof *operator->() { return _ptr; } + operator oneof () const { return *_ptr; } + operator oneof& () { return *_ptr; } + inline friend NCostream& operator<<(NCostream& strm, + const oneof_var& var) { + if (var._ptr == (oneof *)NULL) { + throw CORBA::BAD_PARAM(); + } + else + strm << *var._ptr; + return strm; + } + inline friend NCistream& operator>>(NCistream& strm, + oneof_var& var) { + if ( ! var._ptr) + var._ptr = new oneof; + strm >> *var._ptr; + return strm; + } + private: + oneof *_ptr; + }; + + + virtual Cubit::oneof cube_union(const Cubit::oneof& values); + + virtual void please_exit(); + + inline friend NCistream& operator>>(NCistream& strm, Cubit_ptr& obj) { + CORBA::Object_var _obj(obj); + _obj = CORBA::Object::_read(strm, Cubit::_desc()); + obj = Cubit::_narrow(_obj); + return strm; + } + inline friend ostream& operator<<(ostream& strm, const Cubit_ptr obj) { + strm << (CORBA::Object_ptr)obj; + return strm; + } + inline friend istream& operator>>(istream& strm, Cubit_ptr& obj) { + NCistream istrm(strm); + istrm >> obj; + return strm; + } +}; + + +#endif + diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/cubitS.cpp b/TAO/performance-tests/Cubit/Orbix/tpr/cubitS.cpp new file mode 100644 index 00000000000..4dff3946d8b --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/cubitS.cpp @@ -0,0 +1,230 @@ +// $Id$ + +#include "cubit.h" + + +ACE_RCSID(tpr, cubitS, "$Id$") + +#define Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void *IT_pp) { + if (!IT_pp) + IT_pp = m_obj; + const char *IT_s = IT_r.getOperation (); + if (!strcmp(IT_s,"cube_octet")) { + CORBA::Octet IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_octet~+o{o},>{o},N{}\ +")) + return 1; + CORBA::Octet o; + + IT_r.extractOctet (o); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_octet ( o, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +o\ +", IT_env)) return 1; + IT_r.insertOctet (IT_result); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_short")) { + CORBA::Short IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_short~+s{s},>{s},N{}\ +")) + return 1; + CORBA::Short s; + + IT_r >> s; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_short ( s, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +s\ +", IT_env)) return 1; + IT_r << IT_result; + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_long")) { + CORBA::Long IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_long~+l{l},>{l},N{}\ +")) + return 1; + CORBA::Long l; + + IT_r >> l; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_long ( l, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +l\ +", IT_env)) return 1; + IT_r << IT_result; + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_struct")) { + Cubit::Many IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_struct~+values{R~Cubit::Many~o{o},l{l},s{s}},>{R~Cubit::Many~o{o},l{l},s{s}},N{}\ +")) + return 1; + Cubit::Many values; + + values.decodeOp (IT_r); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_struct ( values, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +R~Cubit::Many~o{o},l{l},s{s}\ +", IT_env)) return 1; + IT_result.encodeOp (IT_r); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_union")) { + Cubit::oneof IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + IT_r.tcPreAssert ( +"\ +Ro~cube_union~+values{U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}},>{U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,\ +"); + if (!IT_r.tcAssert ("\ +e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}},N{}\ +")) + return 1; + Cubit::oneof values; + + values.decodeOp (IT_r); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_union ( values, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}\ +", IT_env)) return 1; + IT_result.encodeOp (IT_r); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"please_exit")) { + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~please_exit~>{v},O{}\ +")) + return 1; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + ((Cubit*)IT_pp)->please_exit (IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env); + return 1; + } + + if (IT_isTarget) + IT_r.makeRuntimeException2 (); + + return 0; +} + +#include "cubitC.cpp" + diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/cubitS.h b/TAO/performance-tests/Cubit/Orbix/tpr/cubitS.h new file mode 100644 index 00000000000..3ca717e2b49 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/cubitS.h @@ -0,0 +1,120 @@ +// $Id$ + +#ifndef _cubitS_h +#define _cubitS_h + +#include "cubitC.h" + +/************************************************************************/ +/* */ +/* This file is automatically generated by ORBeline IDL compiler */ +/* Do not modify this file. */ +/* */ +/* ORBeline (c) is copyrighted by PostModern Computing, Inc. */ +/* */ +/* The generated code conforms to OMG's IDL C++ mapping as */ +/* specified in OMG Document Number: 94-9-14. */ +/* */ +/************************************************************************/ + +class _sk_Cubit : public Cubit +{ + protected: + _sk_Cubit(const char *object_name = (const char *)NULL); + _sk_Cubit(const char *service_name, const CORBA::ReferenceData& data); + virtual ~_sk_Cubit() {} + public: + static const CORBA::TypeInfo _skel_info; + + // The following operations need to be implemented by the server. + virtual CORBA::Octet cube_octet(CORBA::Octet o) = 0; + virtual CORBA::Short cube_short(CORBA::Short s) = 0; + virtual CORBA::Long cube_long(CORBA::Long l) = 0; + virtual Cubit::Many cube_struct(const Cubit::Many& values) = 0; + virtual Cubit::oneof cube_union(const Cubit::oneof& values) = 0; + virtual void please_exit() = 0; + + // Skeleton Operations implemented automatically + + static void _cube_octet(void *obj, + CORBA::MarshalStream &strm, + CORBA::Principal_ptr principal, + const char *oper, + void *priv_data); + + static void _cube_short(void *obj, + CORBA::MarshalStream &strm, + CORBA::Principal_ptr principal, + const char *oper, + void *priv_data); + + static void _cube_long(void *obj, + CORBA::MarshalStream &strm, + CORBA::Principal_ptr principal, + const char *oper, + void *priv_data); + + static void _cube_struct(void *obj, + CORBA::MarshalStream &strm, + CORBA::Principal_ptr principal, + const char *oper, + void *priv_data); + + static void _cube_union(void *obj, + CORBA::MarshalStream &strm, + CORBA::Principal_ptr principal, + const char *oper, + void *priv_data); + + static void _please_exit(void *obj, + CORBA::MarshalStream &strm, + CORBA::Principal_ptr principal, + const char *oper, + void *priv_data); + +}; +template <class T> +class _tie_Cubit : public Cubit +{ + public: + _tie_Cubit(T& t, const char *obj_name=(char*)NULL) : + Cubit(obj_name), + _ref(t) { + _object_name(obj_name); + } + _tie_Cubit(T& t, const char *service_name, + const CORBA::ReferenceData& id) + :_ref(t) { + _service(service_name, id); + } + ~_tie_Cubit() {} + CORBA::Octet cube_octet(CORBA::Octet o) { + return _ref.cube_octet( + o); + } + CORBA::Short cube_short(CORBA::Short s) { + return _ref.cube_short( + s); + } + CORBA::Long cube_long(CORBA::Long l) { + return _ref.cube_long( + l); + } + Cubit::Many cube_struct(const Cubit::Many& values) { + return _ref.cube_struct( + values); + } + Cubit::oneof cube_union(const Cubit::oneof& values) { + return _ref.cube_union( + values); + } + void please_exit() { + _ref.please_exit(); + } + + private: + T& _ref; +}; + +#endif + diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/cubit_impl.cpp b/TAO/performance-tests/Cubit/Orbix/tpr/cubit_impl.cpp new file mode 100644 index 00000000000..d0fea470713 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/cubit_impl.cpp @@ -0,0 +1,50 @@ +// $Id$ + +#include "cubit_impl.h" + +ACE_RCSID(tpr, cubit_impl, "$Id$") + +CORBA::Octet Cubit_Impl:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Octet) (o * o * o); +} + +CORBA::Short Cubit_Impl:: cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Short) (s * s * s); +} + +CORBA::Long Cubit_Impl:: cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + return (CORBA::Long) (l * l * l); +} + +Cubit::Many Cubit_Impl:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + Cubit::Many out_values; + out_values.o = values.o * values.o * values.o; + out_values.s = values.s * values.s * values.s; + out_values.l = values.l * values.l * values.l; + return out_values; +} + +Cubit::oneof Cubit_Impl:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException) { + Cubit::oneof out_values; + switch (values._d ()) { + case Cubit::e_0th: + out_values.o (values.o () * values.o () * values.o ()); + break; + case Cubit::e_1st: + out_values.s (values.s () * values.s () * values.s ()); + break; + case Cubit::e_2nd: + out_values.l (values.l () * values.l () * values.l ()); + break; + case Cubit::e_3rd: + default: + out_values.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o ; + out_values.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s ; + out_values.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l ; + break; + } + return out_values; +} + +void Cubit_Impl:: please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException) { +} diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/cubit_impl.h b/TAO/performance-tests/Cubit/Orbix/tpr/cubit_impl.h new file mode 100644 index 00000000000..033aa7f0cb1 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/cubit_impl.h @@ -0,0 +1,29 @@ +// $Id$ + + +#ifndef cubit_ih +#define cubit_ih + +#include "cubit.h" + + +#ifdef Cubit_USE_BOA +class Cubit_Impl : public virtual CubitBOAImpl { +#else +class Cubit_Impl { +#endif /* Cubit_USE_BOA */ + +public: + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); +}; + +#ifndef Cubit_USE_BOA +DEF_TIE_Cubit (Cubit_Impl) +#endif /* Cubit_USE_BOA */ + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/server.cpp b/TAO/performance-tests/Cubit/Orbix/tpr/server.cpp new file mode 100644 index 00000000000..a47b9aea225 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/server.cpp @@ -0,0 +1,44 @@ +// $Id$ + +//************************************************************************** +// +// NAME : tpr_server.cpp +// DESCRIPTION: +// +// Server mainline +// +//**************************************************************************** +#define IT_EX_MACROS + +#include "cubit_impl.h" // server header file + +ACE_RCSID(tpr, server, "$Id$") + +int +main (int , char**) +{ + +#ifdef Cubit_USE_BOA + Cubit_var cb = new Cubit_Impl; + cout << "Using BOA approach" << endl; +#else + Cubit_var cb = new TIE_Cubit (Cubit_Impl) (new Cubit_Impl); + cout << "Using TIE approach" << endl; +#endif /* Cubit_USE_BOA */ + + // + // Go get some work to do.... + // + IT_TRY { + CORBA::Orbix.impl_is_ready("Cubit", IT_X); + } + IT_CATCHANY { + cout << IT_X << endl; + } + IT_ENDTRY; + + cout << "Cubit server is exiting." << endl; + + + return 0; +} diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/tpr.cpp b/TAO/performance-tests/Cubit/Orbix/tpr/tpr.cpp new file mode 100644 index 00000000000..571188cc77a --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/tpr.cpp @@ -0,0 +1,32 @@ +// $Id$ + +#include "tpr.h" + +ACE_RCSID(tpr, tpr, "$Id$") + +ACE_RCSID(tpr, tpr, "$Id$") + +void * +worker(void *vp) +{ + ACE_Thread_Control tc (ACE_Thread_Manager::instance ()); + CORBA::Orbix.continueThreadDispatch (*(CORBA::Request *)vp); + return NULL; +} + + +int +tpr_filter::inRequestPreMarshal(CORBA::Request &r, CORBA::Environment&) +{ +// thread_t tid; +// thr_create(NULL, 0, worker, (void *)&r, THR_DETACHED, &tid); + + ACE_Thread_Manager *thr_mgr = ACE_Thread_Manager::instance (); + thr_mgr->spawn (ACE_THR_FUNC (worker), + (void *) &r, + THR_DETACHED); + + return -1; +} + +tpr_filter tpr_dispatcher; diff --git a/TAO/performance-tests/Cubit/Orbix/tpr/tpr.h b/TAO/performance-tests/Cubit/Orbix/tpr/tpr.h new file mode 100644 index 00000000000..b5e8be94cf1 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tpr/tpr.h @@ -0,0 +1,12 @@ +// $Id$ + +#include "cubit.h" +#include "ace/Service_Config.h" +#include "ace/Thread_Manager.h" + +// +// Create a thread filter to dispatch incoming calls +// +class tpr_filter : public CORBA::ThreadFilter { + virtual int inRequestPreMarshal(CORBA::Request &, CORBA::Environment&); +}; diff --git a/TAO/performance-tests/Cubit/Orbix/tps/Makefile b/TAO/performance-tests/Cubit/Orbix/tps/Makefile new file mode 100644 index 00000000000..5130d054a5d --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/Makefile @@ -0,0 +1,349 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the ACE_MT_CORBA_Handler tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +SRC = cubitS.cpp cubit_impl.cpp server.cpp tps.cpp + +SVR_OBJS = cubitS.o cubit_impl.o server.o tps.o + +LDLIBS = + +VLDLIBS = $(LDLIBS:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU +include $(ACE_ROOT)/include/makeinclude/rules.bin.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU + +#---------------------------------------------------------------------------- +# Orbix related macros and target settings. +#---------------------------------------------------------------------------- + + +ORBIX_BINDIR = $(ORBIX_ROOT)/bin +ORBIX_LIBDIR = $(ORBIX_ROOT)/corba2/lib +ORBIX_INCDIR = $(ORBIX_ROOT)/corba2/include + +# Remove -DCubit_USE_BOA from below to use the TIE approach + +CPPFLAGS += -DEXCEPTIONS -I$(ORBIX_INCDIR) -DWANT_ORBIX_FDS -DCubit_USE_BOA +LDFLAGS += -L$(ORBIX_LIBDIR) -R $(ORBIX_LIBDIR) -L$(ACE)/ace + +IDLFLAGS = -s S.cpp -c C.cpp -B + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +all: server + +server: $(addprefix $(VDIR),$(SVR_OBJS)) + $(LINK.cc) -o server $(addprefix $(VDIR),$(SVR_OBJS)) $(LDFLAGS) $(ITIIOP) $(ITSRV) $(VLDLIBS) $(POSTLINK) + +#---------------------------------------------------------------------------- +# Dependencies +#---------------------------------------------------------------------------- +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubitS.o .shobj/cubitS.so: cubitS.cpp cubit.h cubitC.cpp +.obj/cubit_impl.o .shobj/cubit_impl.so: cubit_impl.cpp cubit_impl.h cubit.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Token.h \ + $(ACE_ROOT)/ace/Token.i \ + $(ACE_ROOT)/ace/Pipe.h \ + $(ACE_ROOT)/ace/Pipe.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Proactor.h \ + $(ACE_ROOT)/ace/Asynch_IO.h \ + $(ACE_ROOT)/ace/Timer_List.h \ + $(ACE_ROOT)/ace/Timer_List_T.h \ + $(ACE_ROOT)/ace/Timer_Heap.h \ + $(ACE_ROOT)/ace/Timer_Heap_T.h \ + $(ACE_ROOT)/ace/Timer_Wheel.h \ + $(ACE_ROOT)/ace/Timer_Wheel_T.h \ + $(ACE_ROOT)/ace/ReactorEx.h \ + $(ACE_ROOT)/ace/ReactorEx.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i +.obj/server.o .shobj/server.so: server.cpp cubit_impl.h cubit.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Token.h \ + $(ACE_ROOT)/ace/Token.i \ + $(ACE_ROOT)/ace/Pipe.h \ + $(ACE_ROOT)/ace/Pipe.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Proactor.h \ + $(ACE_ROOT)/ace/Asynch_IO.h \ + $(ACE_ROOT)/ace/Timer_List.h \ + $(ACE_ROOT)/ace/Timer_List_T.h \ + $(ACE_ROOT)/ace/Timer_Heap.h \ + $(ACE_ROOT)/ace/Timer_Heap_T.h \ + $(ACE_ROOT)/ace/Timer_Wheel.h \ + $(ACE_ROOT)/ace/Timer_Wheel_T.h \ + $(ACE_ROOT)/ace/ReactorEx.h \ + $(ACE_ROOT)/ace/ReactorEx.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i +.obj/tps.o .shobj/tps.so: tps.cpp tps.h cubit.h cubit_impl.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5-sunc++-4.x.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Token.h \ + $(ACE_ROOT)/ace/Token.i \ + $(ACE_ROOT)/ace/Pipe.h \ + $(ACE_ROOT)/ace/Pipe.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Proactor.h \ + $(ACE_ROOT)/ace/Asynch_IO.h \ + $(ACE_ROOT)/ace/Timer_List.h \ + $(ACE_ROOT)/ace/Timer_List_T.h \ + $(ACE_ROOT)/ace/Timer_Heap.h \ + $(ACE_ROOT)/ace/Timer_Heap_T.h \ + $(ACE_ROOT)/ace/Timer_Wheel.h \ + $(ACE_ROOT)/ace/Timer_Wheel_T.h \ + $(ACE_ROOT)/ace/ReactorEx.h \ + $(ACE_ROOT)/ace/ReactorEx.i \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/Task_T.i + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/Orbix/tps/cubit.h b/TAO/performance-tests/Cubit/Orbix/tps/cubit.h new file mode 100644 index 00000000000..3a2dd546608 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/cubit.h @@ -0,0 +1,1113 @@ +// $Id$ + + +#ifndef cubit_hh +#define cubit_hh + +#include <CORBA.h> + +#include <string.h> + + +#ifndef _Cubit_defined +#define _Cubit_defined +class Cubit_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch () {} + + Cubit_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit; + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + + +#ifndef CubitForwH +#define CubitForwH +CORBA::ObjectRef Cubit_getBase (void *); +void Cubit_release (Cubit *, CORBA::Environment &IT_env); +void Cubit_release (Cubit_ptr); +Cubit* Cubit_duplicate (Cubit_ptr, CORBA::Environment &IT_env); +Cubit* Cubit_duplicate (Cubit_ptr ); +Cubit_ptr Cubit_nil (CORBA::Environment &IT_env); +Cubit_ptr Cubit_nil (); +#endif +#define Cubit_IMPL "Cubit" + + +class Cubit; + +typedef Cubit CubitProxy; +#define Cubit_IR "Cubit$v1.1" +#define Cubit_IMPL "Cubit" + +#ifndef CubitPtr +#define CubitPtr + +typedef Cubit* Cubit_ptr; + +typedef Cubit* CubitRef; + +#endif + +class Cubit: public virtual CORBA::Object { +public: + Cubit (char *IT_OR); + Cubit (ObjectReference *IT_OR); + Cubit () : CORBA::Object (1) {} +protected: + Cubit_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_ptr _duplicate( + Cubit_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _bind (CORBA::Environment &IT_env); + static Cubit* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_ptr) CORBA::OBJECT_NIL;} + +#ifndef Cubit_Many_defined +#define Cubit_Many_defined + +struct Many { + CORBA::Octet o; + CORBA::Long l; + CORBA::Short s; + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + Many(const Many &); + Many(); + ~Many(); + Many& operator= (const Many&); +}; + +#ifndef Cubit_ManyVarH +#define Cubit_ManyVarH + +#ifndef Cubit_ManyvPtr +#define Cubit_ManyvPtr +typedef Many* Many_vPtr; +typedef const Many* Many_cvPtr; +#endif + +class Many_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Many_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + Many_var (const Many_var &IT_s) { + (void) copyHelper (IT_s); + } + + Many_var () { + _ptr = new Many; +; + } + + Many_var (Many *IT_p) { + _ptr = IT_p; + } + + Many_var &operator= (Many *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + Many_var &operator= (const Many_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new Many; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~Many_var () { + delete _ptr; + } + + Many* operator-> () { + return _ptr; + } + + operator Many_cvPtr () const { return _ptr;} + operator Many_vPtr& () { return _ptr;} + operator Many& () const { return * _ptr;} + + protected: + Many *_ptr; + private: + Many_var &operator= (const CORBA::_var &IT_s); + Many_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + +enum discrim {e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th, IT__ENUM_Cubit_discrim=CORBA_ULONG_MAX}; + +#ifndef Cubit_oneof_defined +#define Cubit_oneof_defined + +struct oneof { + private: + + discrim __d; + union { + CORBA::Octet _o_; + CORBA::Short _s_; + CORBA::Long _l_; + Many * _cm_; + }; + + public: + + void encodeOp (CORBA::Request &IT_r) const; + void decodeOp (CORBA::Request &IT_r); + void decodeInOutOp (CORBA::Request &IT_r); + + private: + + unsigned char isSet; + + public: + + discrim _d () const { return __d; } + + CORBA::Octet o () const { + return _o_; + } + + void o (CORBA::Octet IT_member) { + if (isSet && (__d != Cubit::e_0th)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_0th; + isSet = 1; + _o_ = IT_member; + } + + CORBA::Short s () const { + return _s_; + } + + void s (CORBA::Short IT_member) { + if (isSet && (__d != Cubit::e_1st)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_1st; + isSet = 1; + _s_ = IT_member; + } + + CORBA::Long l () const { + return _l_; + } + + void l (CORBA::Long IT_member) { + if (isSet && (__d != Cubit::e_2nd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_2nd; + isSet = 1; + _l_ = IT_member; + } + + Many& cm () { + return (*_cm_); + } + + const Many& cm () const { + return (*_cm_); + } + + void cm (const Many& IT_member) { + if (isSet && (__d != Cubit::e_3rd)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = Cubit::e_3rd; + + if (!isSet) { + _cm_ = new Many; + isSet = 1; + } + *(_cm_) = IT_member; + } + + + oneof(); + oneof(const oneof &); + ~oneof(); + oneof& operator= (const oneof&); +}; + +#ifndef Cubit_oneofVarH +#define Cubit_oneofVarH + +#ifndef Cubit_oneofvPtr +#define Cubit_oneofvPtr +typedef oneof* oneof_vPtr; +typedef const oneof* oneof_cvPtr; +#endif + +class oneof_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const oneof_var &IT_s) { + if (!IT_s._ptr) { + _ptr = IT_s._ptr; + } else + { + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + } + return 1; + } + + public: + + oneof_var (const oneof_var &IT_s) { + (void) copyHelper (IT_s); + } + + oneof_var () { + _ptr = NULL; + } + + oneof_var (oneof *IT_p) { + _ptr = IT_p; + } + + oneof_var &operator= (oneof *IT_p) { + if (_ptr != IT_p) { + delete _ptr; + } + _ptr = IT_p; + return (*this); + } + + oneof_var &operator= (const oneof_var &IT_s) { + if (_ptr != IT_s._ptr) { + delete _ptr; + } + _ptr = new oneof; + *(_ptr) = *(IT_s._ptr); + return (*this); + } + + ~oneof_var () { + delete _ptr; + } + + oneof* operator-> () { + return _ptr; + } + + operator oneof_cvPtr () const { return _ptr;} + operator oneof_vPtr& () { return _ptr;} + operator oneof& () const { return * _ptr;} + + protected: + oneof *_ptr; + private: + oneof_var &operator= (const CORBA::_var &IT_s); + oneof_var (const CORBA::_var &IT_s); +}; + +#endif + + +#endif + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef CubitVarH +#define CubitVarH + +#ifndef CubitvPtr +#define CubitvPtr +typedef Cubit* Cubit_vPtr; +typedef const Cubit* Cubit_cvPtr; +#endif + +class Cubit_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_var &IT_s) { + { + _ptr = Cubit_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_var (const Cubit_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_var () { + _ptr = Cubit_nil (); + } + + Cubit_var (Cubit *IT_p) { + _ptr = IT_p; + } + + Cubit_var &operator= (Cubit *IT_p) { + Cubit_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_var &operator= (const Cubit_var &IT_s) { + Cubit_release (_ptr); + _ptr = Cubit_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_var () { + Cubit_release (_ptr); + } + + Cubit* operator-> () { + return _ptr; + } + + operator Cubit_cvPtr () const { return _ptr;} + operator Cubit_vPtr& () { return _ptr;} + + protected: + Cubit *_ptr; + private: + Cubit_var &operator= (const CORBA::_var &IT_s); + Cubit_var (const CORBA::_var &IT_s); + Cubit_var &operator= (const CORBA::_mgr &IT_s); + Cubit_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_var (const CORBA::_mgr &IT_s); + Cubit_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef CubitMgrH +#define CubitMgrH + +class Cubit_mgr : public CORBA::_mgr +{ + public: + + Cubit_mgr () { + _ptr = Cubit_nil (); + _release = 1; + } + + Cubit_mgr (const Cubit_mgr &IT_s) { + _ptr = Cubit_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_mgr &operator= (Cubit *IT_p) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (const Cubit_mgr &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_mgr &operator= (Cubit_var &IT_s) { + if (_ptr && _release) + Cubit_release (_ptr); + _ptr = Cubit_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_mgr () { + if (_release) + Cubit_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit* () const { + return (Cubit*) _ptr; + } + + Cubit_ptr operator-> () const { + return _ptr; + } + + Cubit *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_mgr Cubit_mgr_IT_const; +#endif + +#ifndef CubitSeqElemH +#define CubitSeqElemH + +class Cubit_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_SeqElem &operator= (Cubit_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_SeqElem &operator= (const Cubit_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_release (*(_ptr)); + *(_ptr) = Cubit_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_ptr () const { + return _ptr ? (Cubit_ptr) (*_ptr) : Cubit_nil(); + } + + Cubit_ptr operator->() const { return *_ptr;} + + protected: + Cubit_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit(X) Cubit##X + +#define DEF_TIE_Cubit(X) \ + class Cubit##X : public virtual Cubit { \ + X* m_obj; \ + public: \ + \ + \ + Cubit##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit(), m_obj(objp) { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,m,l,Cubit_IR,m_obj); \ + } \ + Cubit##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit() { \ + m_pptr = new Cubit_dispatch \ + (( Cubit*)this,(CORBA::Object*)this,IT_m,Cubit_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit \ +virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_octet ( o,IT_env);\ +}\ + \ +virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_short ( s,IT_env);\ +}\ + \ +virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_long ( l,IT_env);\ +}\ + \ +virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_struct ( values,IT_env);\ +}\ + \ +virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->cube_union ( values,IT_env);\ +}\ + \ +virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +m_obj->please_exit (IT_env);\ +}\ + + + + +class CubitProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + CubitProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern CubitProxyFactoryClass CubitProxyFactory; + +class CubitBOAImpl : public virtual Cubit { +public: + CubitBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_IR)) + m_pptr = new Cubit_dispatch ( (Cubit*)this, + (CORBA::Object*)this, m, l, Cubit_IR, this); +} + + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; + virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#ifndef _Cubit_Factory_defined +#define _Cubit_Factory_defined +class Cubit_Factory_dispatch : public virtual CORBA::PPTR { +public: + + Cubit_Factory_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, + CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {} + + + Cubit_Factory_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_Factory_dispatch () {} + + Cubit_Factory_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o) + : PPTR (IT_OR,IT_p,IT_o) {} + + + Cubit_Factory_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, + char *IT_i, CORBA::Object* IT_ob, void* IT_im) + : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {} + + + virtual unsigned char dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void* IT_pp=NULL); + + +}; + +class Cubit_Factory; + +#ifndef Cubit_FactoryPtr +#define Cubit_FactoryPtr + +typedef Cubit_Factory* Cubit_Factory_ptr; + +typedef Cubit_Factory* Cubit_FactoryRef; + +#endif + + +#ifndef Cubit_FactoryForwH +#define Cubit_FactoryForwH +CORBA::ObjectRef Cubit_Factory_getBase (void *); +void Cubit_Factory_release (Cubit_Factory *, CORBA::Environment &IT_env); +void Cubit_Factory_release (Cubit_Factory_ptr); +Cubit_Factory* Cubit_Factory_duplicate (Cubit_Factory_ptr, CORBA::Environment &IT_env); +Cubit_Factory* Cubit_Factory_duplicate (Cubit_Factory_ptr ); +Cubit_Factory_ptr Cubit_Factory_nil (CORBA::Environment &IT_env); +Cubit_Factory_ptr Cubit_Factory_nil (); +#endif +#define Cubit_Factory_IMPL "Cubit_Factory" + + +class Cubit_Factory; + +typedef Cubit_Factory Cubit_FactoryProxy; +#define Cubit_Factory_IR "Cubit_Factory" +#define Cubit_Factory_IMPL "Cubit_Factory" + +#ifndef Cubit_FactoryPtr +#define Cubit_FactoryPtr + +typedef Cubit_Factory* Cubit_Factory_ptr; + +typedef Cubit_Factory* Cubit_FactoryRef; + +#endif + +class Cubit_Factory: public virtual CORBA::Object { +public: + Cubit_Factory (char *IT_OR); + Cubit_Factory (ObjectReference *IT_OR); + Cubit_Factory () : CORBA::Object (1) {} +protected: + Cubit_Factory_ptr __duplicate( + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) { + CORBA::Object::__duplicate (IT_env); + return this; + } +public: + static Cubit_Factory_ptr _duplicate( + Cubit_Factory_ptr, + CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()); +public: + static Cubit_Factory* _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory* _bind (CORBA::Environment &IT_env); + static Cubit_Factory* _bind (const char* IT_markerServer=NULL, const char* host=NULL, + CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + static Cubit_Factory_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + return (Cubit_Factory_ptr) CORBA::OBJECT_NIL;} + virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException); +}; + +#ifndef Cubit_FactoryVarH +#define Cubit_FactoryVarH + +#ifndef Cubit_FactoryvPtr +#define Cubit_FactoryvPtr +typedef Cubit_Factory* Cubit_Factory_vPtr; +typedef const Cubit_Factory* Cubit_Factory_cvPtr; +#endif + +class Cubit_Factory_var : public CORBA::_var +{ + private: + + unsigned char copyHelper (const Cubit_Factory_var &IT_s) { + { + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + } + return 1; + } + + public: + + Cubit_Factory_var (const Cubit_Factory_var &IT_s) { + (void) copyHelper (IT_s); + } + + Cubit_Factory_var () { + _ptr = Cubit_Factory_nil (); + } + + Cubit_Factory_var (Cubit_Factory *IT_p) { + _ptr = IT_p; + } + + Cubit_Factory_var &operator= (Cubit_Factory *IT_p) { + Cubit_Factory_release (_ptr); + _ptr = IT_p; + return (*this); + } + + Cubit_Factory_var &operator= (const Cubit_Factory_var &IT_s) { + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + return (*this); + } + + ~Cubit_Factory_var () { + Cubit_Factory_release (_ptr); + } + + Cubit_Factory* operator-> () { + return _ptr; + } + + operator Cubit_Factory_cvPtr () const { return _ptr;} + operator Cubit_Factory_vPtr& () { return _ptr;} + + protected: + Cubit_Factory *_ptr; + private: + Cubit_Factory_var &operator= (const CORBA::_var &IT_s); + Cubit_Factory_var (const CORBA::_var &IT_s); + Cubit_Factory_var &operator= (const CORBA::_mgr &IT_s); + Cubit_Factory_var &operator= (const CORBA::_SeqElem &IT_s); + Cubit_Factory_var (const CORBA::_mgr &IT_s); + Cubit_Factory_var (const CORBA::_SeqElem &IT_s); +}; + +#endif + + +#ifndef Cubit_FactoryMgrH +#define Cubit_FactoryMgrH + +class Cubit_Factory_mgr : public CORBA::_mgr +{ + public: + + Cubit_Factory_mgr () { + _ptr = Cubit_Factory_nil (); + _release = 1; + } + + Cubit_Factory_mgr (const Cubit_Factory_mgr &IT_s) { + _ptr = Cubit_Factory_duplicate (IT_s._ptr); + _release = 1; + } + + Cubit_Factory_mgr &operator= (Cubit_Factory *IT_p) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = IT_p; + _release = 1; + return (*this); + } + + Cubit_Factory_mgr &operator= (const Cubit_Factory_mgr &IT_s) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate(IT_s._ptr); + _release = 1; + return (*this); + } + + Cubit_Factory_mgr &operator= (Cubit_Factory_var &IT_s) { + if (_ptr && _release) + Cubit_Factory_release (_ptr); + _ptr = Cubit_Factory_duplicate(IT_s); + _release = 1; + return (*this); + } + + ~Cubit_Factory_mgr () { + if (_release) + Cubit_Factory_release (_ptr); + } + + unsigned char release () { + return _release; + } + + void release (unsigned char rel) { + _release = rel; + } + + operator int () const { + return (((CORBA::Object_ptr) _ptr) ? 1 : 0); + } + + operator void* () const { + return _ptr; + } + + operator CORBA::Object * () const { + return (CORBA::Object *) _ptr; + } + + operator Cubit_Factory* () const { + return (Cubit_Factory*) _ptr; + } + + Cubit_Factory_ptr operator-> () const { + return _ptr; + } + + Cubit_Factory *_ptr; + + protected: + + unsigned char _release; +}; + +typedef Cubit_Factory_mgr Cubit_Factory_mgr_IT_const; +#endif + +#ifndef Cubit_FactorySeqElemH +#define Cubit_FactorySeqElemH + +class Cubit_Factory_SeqElem : public CORBA::_SeqElem +{ + public: + + Cubit_Factory_SeqElem (Cubit_Factory_ptr* IT_p, unsigned char rel) { + _ptr = IT_p; + _release = rel; + } + + Cubit_Factory_SeqElem &operator= (Cubit_Factory_ptr IT_p) { + if (_ptr) { + if (*(_ptr) && _release) + Cubit_Factory_release (*(_ptr)); + *(_ptr) = IT_p; + } + return (*this); + } + + Cubit_Factory_SeqElem &operator= (const Cubit_Factory_SeqElem &IT_s) { + if (_ptr && IT_s._ptr) { + if (*(_ptr) && _release) + Cubit_Factory_release (*(_ptr)); + *(_ptr) = Cubit_Factory_duplicate(*(IT_s._ptr)); + } + return (*this); + } + + operator Cubit_Factory_ptr () const { + return _ptr ? (Cubit_Factory_ptr) (*_ptr) : Cubit_Factory_nil(); + } + + Cubit_Factory_ptr operator->() const { return *_ptr;} + + protected: + Cubit_Factory_ptr *_ptr; + unsigned char _release; +}; + +#endif + + +#define TIE_Cubit_Factory(X) Cubit_Factory##X + +#define DEF_TIE_Cubit_Factory(X) \ + class Cubit_Factory##X : public virtual Cubit_Factory { \ + X* m_obj; \ + public: \ + \ + \ + Cubit_Factory##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\ + : Cubit_Factory(), m_obj(objp) { \ + m_pptr = new Cubit_Factory_dispatch \ + (( Cubit_Factory*)this,(CORBA::Object*)this,m,l,Cubit_Factory_IR,m_obj); \ + } \ + Cubit_Factory##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\ + : Cubit_Factory() { \ + m_pptr = new Cubit_Factory_dispatch \ + (( Cubit_Factory*)this,(CORBA::Object*)this,IT_m,Cubit_Factory_IR,IT_p,IT_q); \ + m_obj = (X*)(m_pptr->getImplObj ()); \ + } \ + \ + virtual ~Cubit_Factory##X () { \ + if (_okToDeleteImpl ()) delete m_obj; } \ + virtual void* _deref () { \ + return m_obj; } \ + \ +virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->create_cubit ( name,IT_env);\ +}\ + \ + }; \ + + +#define QUALS_Cubit_Factory \ +virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env) throw (CORBA::SystemException){\ +return m_obj->create_cubit ( name,IT_env);\ +}\ + + + + +class Cubit_FactoryProxyFactoryClass : public virtual CORBA::ObjectFactoryClass { +public: + Cubit_FactoryProxyFactoryClass (unsigned char IT_p=0) + : CORBA::ProxyFactory (Cubit_Factory_IR, IT_p) {} + + virtual void* New (char *IT_OR, CORBA::Environment&); + + virtual void* New (ObjectReference *IT_OR, CORBA::Environment&); + + virtual void* New2 (); + + virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&); + + virtual CORBA::Object* New2Object (); + + virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()); + + virtual CORBA::PPTR* pptr (void *IT_p); + + virtual void baseInterfaces (_IDL_SEQUENCE_string&); + + +}; + +extern Cubit_FactoryProxyFactoryClass Cubit_FactoryProxyFactory; + +class Cubit_FactoryBOAImpl : public virtual Cubit_Factory { +public: + Cubit_FactoryBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) { + if (CORBA::PPTR::isOK (m_pptr, Cubit_Factory_IR)) + m_pptr = new Cubit_Factory_dispatch ( (Cubit_Factory*)this, + (CORBA::Object*)this, m, l, Cubit_Factory_IR, this); +} + + virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0; +}; + + +#endif + + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/tps/cubit.idl b/TAO/performance-tests/Cubit/Orbix/tps/cubit.idl new file mode 100644 index 00000000000..41309e997ea --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/cubit.idl @@ -0,0 +1,48 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. + +#pragma prefix "Eng.SUN.COM" +#pragma version Cubit 1.1 + + interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); + }; + + + interface Cubit_Factory { + Cubit create_cubit (in string name); + }; + diff --git a/TAO/performance-tests/Cubit/Orbix/tps/cubitC.cpp b/TAO/performance-tests/Cubit/Orbix/tps/cubitC.cpp new file mode 100644 index 00000000000..5791756e6a4 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/cubitC.cpp @@ -0,0 +1,714 @@ +// $Id$ + + + +#include "cubit.h" + +ACE_RCSID(tps, cubitC, "$Id$") + +Cubit::Cubit (char *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} +Cubit::Cubit (ObjectReference *IT_OR) { + m_pptr = new Cubit_dispatch (IT_OR, this,(CORBA::Object*)this); +} + +#ifndef CubitForwC +#define CubitForwC +CORBA::ObjectRef Cubit_getBase(void *IT_p){ + return (Cubit*) IT_p;} + +void Cubit_release (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + CORBA::release(IT_p, IT_env);} + +void Cubit_release (Cubit_ptr IT_p) { + Cubit_release (IT_p, CORBA::IT_chooseDefaultEnv ()); } + +Cubit_ptr Cubit_nil (CORBA::Environment &) { + return Cubit:: _nil ();} + +Cubit_ptr Cubit_nil () { + return Cubit_nil (CORBA::IT_chooseDefaultEnv ());} + +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p, CORBA::Environment &IT_env) { + return (Cubit::_duplicate(IT_p, IT_env)); } +Cubit_ptr Cubit_duplicate (Cubit_ptr IT_p) { + return Cubit_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); } +#endif + +Cubit_ptr Cubit::_duplicate(Cubit_ptr obj, CORBA::Environment& IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (!obj) { + return (obj); + } + Cubit_ptr IT_obj = obj->__duplicate (IT_env); + return IT_obj; +} + + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env) { + return (Cubit*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, + Cubit_IMPL, Cubit_IR); +} + + + +Cubit* Cubit:: _bind (CORBA::Environment &IT_env) { + return _bind (NULL,NULL,CORBA::Context(), IT_env); } + + +Cubit* Cubit:: _bind (const char* IT_markerServer, const char* host, + CORBA::Environment &IT_env) { + return _bind (IT_markerServer, host, CORBA::Context (), IT_env); } +Cubit* Cubit::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (CORBA::is_nil (IT_obj)) { + return Cubit:: _nil(); + } + + Cubit* IT_p = (Cubit*)CORBA::Object::_castDown (IT_obj, Cubit_IR, IT_env); + IT_p = IT_p ? IT_p->__duplicate(IT_env) : NULL; + if ((IT_env) &&(!strcmp(IT_env.exception()->id(), "CORBA::StExcep::BAD_PARAM")) && (((CORBA::BAD_PARAM*)IT_env.exception())-> minor() == NARROW_FAILED)) { + IT_env.exception_free(); + } + return IT_p; + } + + +#ifndef Cubit_Many_Ops +#define Cubit_Many_Ops + +void Cubit::Many:: encodeOp (CORBA::Request &IT_r) const { + + IT_r.insertOctet (o); + + IT_r << l; + + IT_r << s; +} + +void Cubit::Many:: decodeOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +void Cubit::Many:: decodeInOutOp (CORBA::Request &IT_r) { + + IT_r.extractOctet (o); + + IT_r >> l; + + IT_r >> s; +} + +Cubit::Many ::~Many () { +} + +Cubit::Many:: Many (const Cubit::Many &IT_s) + { + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; +} + +Cubit::Many:: Many () { +} + +Cubit::Many &Cubit::Many:: operator= (const Cubit::Many& IT_s) { + if (this == &IT_s) return *this; + o = IT_s.o; + l = IT_s.l; + s = IT_s.s; + return *this; +} + + +#endif + + +#ifndef Cubit_oneof_Ops +#define Cubit_oneof_Ops +void Cubit::oneof:: encodeOp (CORBA::Request &IT_r) const { + if (!isSet) return; + { + CORBA::ULong IT_0 = (CORBA::ULong) __d; + IT_r << IT_0; + } + switch (__d) { + case Cubit::e_0th: + IT_r.insertOctet (_o_); + break; + case Cubit::e_1st: + IT_r << _s_; + break; + case Cubit::e_2nd: + IT_r << _l_; + break; + case Cubit::e_3rd: + default: + (*_cm_).encodeOp (IT_r); + break; + } + +} + +void Cubit::oneof:: decodeOp (CORBA::Request &IT_r) { + isSet = 0; + { + CORBA::ULong IT_1; + IT_r >> IT_1; + __d = Cubit::discrim(IT_1); + } + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + +} +void Cubit::oneof:: decodeInOutOp (CORBA::Request &IT_r) { + Cubit::discrim IT_d; + { + CORBA::ULong IT_2; + IT_r >> IT_2; + IT_d = Cubit::discrim(IT_2); + } + if (IT_d == __d) + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeInOutOp (IT_r); + break; + } + + else { + this->oneof:: ~oneof(); + memset(this, 0, sizeof(*this)); + __d = IT_d; + switch (__d) { + case Cubit::e_0th: + if (!isSet) { + isSet = 1; + } + IT_r.extractOctet (_o_); + break; + case Cubit::e_1st: + if (!isSet) { + isSet = 1; + } + IT_r >> _s_; + break; + case Cubit::e_2nd: + if (!isSet) { + isSet = 1; + } + IT_r >> _l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + (*_cm_).decodeOp (IT_r); + break; + } + isSet = 1; + } + +} + +Cubit::oneof:: oneof() { + memset(this, 0, sizeof(*this)); + isSet = 0; +} + +Cubit::oneof ::~oneof() { + if (!isSet) return; + switch (__d) { + case Cubit::e_0th: break; + case Cubit::e_1st: break; + case Cubit::e_2nd: break; + case Cubit::e_3rd: + default: if (_cm_) delete _cm_; + break; + } + + isSet = 0; +} + +Cubit::oneof:: oneof (const Cubit::oneof &IT_s) { + isSet = 0; + memset(this, 0, sizeof(*this)); + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; +} + +Cubit::oneof& Cubit::oneof:: operator= (const Cubit::oneof & IT_s) { + if (this == &IT_s) return *this; + if (isSet && (__d != IT_s.__d)) + { + this-> oneof::~oneof(); + memset(this, 0, sizeof(*this)); + } + + __d = IT_s.__d; + switch (__d) { + case Cubit::e_0th: isSet = 1; + _o_ = IT_s._o_; + break; + case Cubit::e_1st: isSet = 1; + _s_ = IT_s._s_; + break; + case Cubit::e_2nd: isSet = 1; + _l_ = IT_s._l_; + break; + case Cubit::e_3rd: + default: + if (!isSet) { + _cm_ = new Cubit::Many; + isSet = 1; + } + *(_cm_) = *(IT_s._cm_); + break; + } + isSet = 1; + return *this; +} + + +#endif + +void* CubitProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +void* CubitProxyFactoryClass::New2 () { + return new class Cubit((char*)0);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::NewObject (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit(IT_OR);} + +CORBA::Object* CubitProxyFactoryClass::New2Object () { + return new class Cubit((char*)0);} + +void* CubitProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env) { + void *IT_l; + if (!CORBA::_interfaceCmp (IT_s,Cubit_IR, IT_env)) + return IT_p; + else if (IT_l=CORBA::ObjectFactoryClass::IT_castUp((CORBA::Object*)((class Cubit*)IT_p),IT_s, IT_env)) + return IT_l; + else return NULL; + } + + +CORBA::PPTR* CubitProxyFactoryClass::pptr (void *IT_p) { + return ((class Cubit*)IT_p)->_pptr ();} + +void CubitProxyFactoryClass::baseInterfaces (_IDL_SEQUENCE_string& seq) { + add (seq, Cubit_IR); + CORBA::ObjectFactoryClass::baseInterfaces (seq); +} + +CubitProxyFactoryClass CubitProxyFactory(1); + +CORBA::Octet Cubit:: cube_octet (CORBA::Octet o, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_octet",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r.insertOctet (o); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Octet IT_result; + IT_r.extractOctet (IT_result); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Short Cubit:: cube_short (CORBA::Short s, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_short",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << s; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Short IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +CORBA::Long Cubit:: cube_long (CORBA::Long l, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return 0; + } + CORBA::Request IT_r (this, "cube_long",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r << l; + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + CORBA::Long IT_result; + IT_r >> IT_result; + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return 0; +} + +Cubit::Many Cubit:: cube_struct (const Cubit::Many& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::Many IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_struct",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::Many IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::Many IT_l1; + return IT_l1; + } +} + +Cubit::oneof Cubit:: cube_union (const Cubit::oneof& values, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + { + Cubit::oneof IT_l0; + return IT_l0; + } + } + CORBA::Request IT_r (this, "cube_union",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + values.encodeOp (IT_r); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit::oneof IT_result; + IT_result.decodeOp (IT_r); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + { + Cubit::oneof IT_l1; + return IT_l1; + } +} + +void Cubit:: please_exit (CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return ; + } + CORBA::Request IT_r (this, "please_exit",IT_env,1,1); + + IT_r.invoke (CORBA::Flags(CORBA::INV_NO_RESPONSE), IT_env); + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } +} + + + + + +#ifndef Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char, void *) { + IT_r.makeRuntimeException1 ("Cubit"); + return 0; +} + +#endif + +Cubit_Factory::Cubit_Factory (char *IT_OR) { + m_pptr = new Cubit_Factory_dispatch (IT_OR, this,(CORBA::Object*)this); +} +Cubit_Factory::Cubit_Factory (ObjectReference *IT_OR) { + m_pptr = new Cubit_Factory_dispatch (IT_OR, this,(CORBA::Object*)this); +} + +#ifndef Cubit_FactoryForwC +#define Cubit_FactoryForwC +CORBA::ObjectRef Cubit_Factory_getBase(void *IT_p){ + return (Cubit_Factory*) IT_p;} + +void Cubit_Factory_release (Cubit_Factory_ptr IT_p, CORBA::Environment &IT_env) { + CORBA::release(IT_p, IT_env);} + +void Cubit_Factory_release (Cubit_Factory_ptr IT_p) { + Cubit_Factory_release (IT_p, CORBA::IT_chooseDefaultEnv ()); } + +Cubit_Factory_ptr Cubit_Factory_nil (CORBA::Environment &) { + return Cubit_Factory:: _nil ();} + +Cubit_Factory_ptr Cubit_Factory_nil () { + return Cubit_Factory_nil (CORBA::IT_chooseDefaultEnv ());} + +Cubit_Factory_ptr Cubit_Factory_duplicate (Cubit_Factory_ptr IT_p, CORBA::Environment &IT_env) { + return (Cubit_Factory::_duplicate(IT_p, IT_env)); } +Cubit_Factory_ptr Cubit_Factory_duplicate (Cubit_Factory_ptr IT_p) { + return Cubit_Factory_duplicate (IT_p, CORBA::IT_chooseDefaultEnv ()); } +#endif + +Cubit_Factory_ptr Cubit_Factory::_duplicate(Cubit_Factory_ptr obj, CORBA::Environment& IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (!obj) { + return (obj); + } + Cubit_Factory_ptr IT_obj = obj->__duplicate (IT_env); + return IT_obj; +} + + + +Cubit_Factory* Cubit_Factory:: _bind (const char* IT_markerServer, const char* host, + const CORBA::Context &IT_c, + CORBA::Environment &IT_env) { + return (Cubit_Factory*)CORBA::Factory.New (IT_markerServer, IT_env, IT_c, host, + Cubit_Factory_IMPL, Cubit_Factory_IR); +} + + + +Cubit_Factory* Cubit_Factory:: _bind (CORBA::Environment &IT_env) { + return _bind (NULL,NULL,CORBA::Context(), IT_env); } + + +Cubit_Factory* Cubit_Factory:: _bind (const char* IT_markerServer, const char* host, + CORBA::Environment &IT_env) { + return _bind (IT_markerServer, host, CORBA::Context (), IT_env); } +Cubit_Factory* Cubit_Factory::_narrow (CORBA::Object* IT_obj, CORBA::Environment &IT_pEnv) { + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (CORBA::is_nil (IT_obj)) { + return Cubit_Factory:: _nil(); + } + + Cubit_Factory* IT_p = (Cubit_Factory*)CORBA::Object::_castDown (IT_obj, Cubit_Factory_IR, IT_env); + IT_p = IT_p ? IT_p->__duplicate(IT_env) : NULL; + if ((IT_env) &&(!strcmp(IT_env.exception()->id(), "CORBA::StExcep::BAD_PARAM")) && (((CORBA::BAD_PARAM*)IT_env.exception())-> minor() == NARROW_FAILED)) { + IT_env.exception_free(); + } + return IT_p; + } + +void* Cubit_FactoryProxyFactoryClass::New (char *IT_OR, CORBA::Environment&) { + return new class Cubit_Factory(IT_OR);} + +void* Cubit_FactoryProxyFactoryClass::New (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit_Factory(IT_OR);} + +void* Cubit_FactoryProxyFactoryClass::New2 () { + return new class Cubit_Factory((char*)0);} + +CORBA::Object* Cubit_FactoryProxyFactoryClass::NewObject (char *IT_OR, CORBA::Environment&) { + return new class Cubit_Factory(IT_OR);} + +CORBA::Object* Cubit_FactoryProxyFactoryClass::NewObject (ObjectReference *IT_OR, CORBA::Environment&) { + return new class Cubit_Factory(IT_OR);} + +CORBA::Object* Cubit_FactoryProxyFactoryClass::New2Object () { + return new class Cubit_Factory((char*)0);} + +void* Cubit_FactoryProxyFactoryClass::IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env) { + void *IT_l; + if (!CORBA::_interfaceCmp (IT_s,Cubit_Factory_IR, IT_env)) + return IT_p; + else if (IT_l=CORBA::ObjectFactoryClass::IT_castUp((CORBA::Object*)((class Cubit_Factory*)IT_p),IT_s, IT_env)) + return IT_l; + else return NULL; + } + + +CORBA::PPTR* Cubit_FactoryProxyFactoryClass::pptr (void *IT_p) { + return ((class Cubit_Factory*)IT_p)->_pptr ();} + +void Cubit_FactoryProxyFactoryClass::baseInterfaces (_IDL_SEQUENCE_string& seq) { + add (seq, Cubit_Factory_IR); + CORBA::ObjectFactoryClass::baseInterfaces (seq); +} + +Cubit_FactoryProxyFactoryClass Cubit_FactoryProxyFactory(1); + +Cubit_ptr Cubit_Factory:: create_cubit (const char * name, CORBA::Environment &IT_pEnv) throw (CORBA::SystemException) { + + CORBA::EnvExcRaiser IT_raise; + CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv); + if (IT_env || m_isNull) { + return new Cubit; + } + CORBA::Request IT_r (this, "create_cubit",IT_env,1,0); + if (!IT_r.isException (IT_env)) { + + IT_r.encodeStringOp (name); + } + + IT_r.invoke (CORBA::Flags(0),IT_env); + if (!IT_r.isException (IT_env)) { + Cubit_ptr IT_result; + IT_result = (Cubit*) IT_r.decodeObjRef (Cubit_IR); + IT_r.checkEnv (IT_env); + return IT_result; + } + if (IT_r.exceptionKind () == CORBA::SYSTEM_EXCEPTION) { + IT_r.checkEnv (IT_env); + } + return new Cubit; +} + + + + + +#ifndef Cubit_Factory_dispatch_impl + +unsigned char Cubit_Factory_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char, void *) { + IT_r.makeRuntimeException1 ("Cubit_Factory"); + return 0; +} + +#endif + diff --git a/TAO/performance-tests/Cubit/Orbix/tps/cubitS.cpp b/TAO/performance-tests/Cubit/Orbix/tps/cubitS.cpp new file mode 100644 index 00000000000..19a128e2bca --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/cubitS.cpp @@ -0,0 +1,285 @@ +// $Id$ + + + +#include "cubit.h" + +ACE_RCSID(tps, cubitS, "$Id$") + +#define Cubit_dispatch_impl + +unsigned char Cubit_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void *IT_pp) { + if (!IT_pp) + IT_pp = m_obj; + const char *IT_s = IT_r.getOperation (); + if (!strcmp(IT_s,"cube_octet")) { + CORBA::Octet IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_octet~+o{o},>{o},N{}\ +")) + return 1; + CORBA::Octet o; + + IT_r.extractOctet (o); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_octet ( o, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +o\ +", IT_env)) return 1; + IT_r.insertOctet (IT_result); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_short")) { + CORBA::Short IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_short~+s{s},>{s},N{}\ +")) + return 1; + CORBA::Short s; + + IT_r >> s; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_short ( s, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +s\ +", IT_env)) return 1; + IT_r << IT_result; + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_long")) { + CORBA::Long IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_long~+l{l},>{l},N{}\ +")) + return 1; + CORBA::Long l; + + IT_r >> l; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_long ( l, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +l\ +", IT_env)) return 1; + IT_r << IT_result; + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_struct")) { + Cubit::Many IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~cube_struct~+values{R~Cubit::Many~o{o},l{l},s{s}},>{R~Cubit::Many~o{o},l{l},s{s}},N{}\ +")) + return 1; + Cubit::Many values; + + values.decodeOp (IT_r); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_struct ( values, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +R~Cubit::Many~o{o},l{l},s{s}\ +", IT_env)) return 1; + IT_result.encodeOp (IT_r); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"cube_union")) { + Cubit::oneof IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + IT_r.tcPreAssert ( +"\ +Ro~cube_union~+values{U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}},>{U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,\ +"); + if (!IT_r.tcAssert ("\ +e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}},N{}\ +")) + return 1; + Cubit::oneof values; + + values.decodeOp (IT_r); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit*)IT_pp)->cube_union ( values, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +U~Cubit::oneof~{E~Cubit::discrim~e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th}~Cubit::e_0th o{o};Cubit::e_1st s{s};Cubit::e_2nd l{l};Cubit::e_3rd,$ cm{R~Cubit::Many~o{o},l{l},s{s}}\ +", IT_env)) return 1; + IT_result.encodeOp (IT_r); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (!strcmp(IT_s,"please_exit")) { + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~please_exit~>{v},O{}\ +")) + return 1; + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + ((Cubit*)IT_pp)->please_exit (IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + IT_r.replyNoResults (CORBA::Flags(CORBA::INV_NO_RESPONSE),IT_env); + return 1; + } + + if (IT_isTarget) + IT_r.makeRuntimeException2 (); + + return 0; +} + +#define Cubit_Factory_dispatch_impl + +unsigned char Cubit_Factory_dispatch::dispatch (CORBA::Request &IT_r, + unsigned char IT_isTarget, void *IT_pp) { + if (!IT_pp) + IT_pp = m_obj; + const char *IT_s = IT_r.getOperation (); + if (!strcmp(IT_s,"create_cubit")) { + Cubit_ptr IT_result; + CORBA::Environment IT_env (IT_r); + CORBA::Filter* IT_f = CORBA::Orbix.getFilter (); + if (!IT_r.tcAssert ("\ +Ro~create_cubit~+name{0},>{O~Cubit},N{}\ +")) + return 1; + char * name; + + IT_r.decodeStringOp(name); + + if (IT_f && !IT_r.isException (IT_env)) + IT_f->inRequestPostM (IT_r, IT_env); + if (!IT_r.isException (IT_env)) { + try { + IT_result = ((Cubit_Factory*)IT_pp)->create_cubit ( name, IT_env); + + } catch (CORBA::SystemException &IT_exSys) { + IT_env.propagate (&IT_exSys); + } catch (CORBA::UserException &IT_exUsr) { + IT_env.propagate (&IT_exUsr); + } + } + CORBA::string_free (name); + + if (!IT_r.isException (IT_env)) { + if (!IT_r.convertToReply ("\ +O~Cubit\ +", IT_env)) return 1; + { + CORBA::Object* IT_l1 = (CORBA::Object*) IT_result; + IT_r << IT_l1; + } + if (IT_result) Cubit_release (IT_result); + } + + else IT_r.makeSystemException (IT_env); + return 1; + } + + if (IT_isTarget) + IT_r.makeRuntimeException2 (); + + return 0; +} + +#include "cubitC.cpp" + diff --git a/TAO/performance-tests/Cubit/Orbix/tps/cubit_impl.cpp b/TAO/performance-tests/Cubit/Orbix/tps/cubit_impl.cpp new file mode 100644 index 00000000000..94c1c4262d1 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/cubit_impl.cpp @@ -0,0 +1,85 @@ +// $Id$ + +#include "cubit_impl.h" + +ACE_RCSID(tps, cubit_impl, "$Id$") + +CORBA::Octet Cubit_Impl:: cube_octet (CORBA::Octet o, CORBA::Environment &) throw (CORBA::SystemException) { + return (CORBA::Octet) (o * o * o); +} + +CORBA::Short Cubit_Impl:: cube_short (CORBA::Short s, CORBA::Environment &) throw (CORBA::SystemException) { + return (CORBA::Short) (s * s * s); +} + +CORBA::Long Cubit_Impl:: cube_long (CORBA::Long l, CORBA::Environment &) throw (CORBA::SystemException) { + return (CORBA::Long) (l * l * l); +} + +Cubit::Many Cubit_Impl:: cube_struct (const Cubit::Many& values, CORBA::Environment &) throw (CORBA::SystemException) { + Cubit::Many out_values; + out_values.o = values.o * values.o * values.o; + out_values.s = values.s * values.s * values.s; + out_values.l = values.l * values.l * values.l; + return out_values; +} + +Cubit::oneof Cubit_Impl:: cube_union (const Cubit::oneof& values, CORBA::Environment &) throw (CORBA::SystemException) { + Cubit::oneof out_values; + switch (values._d ()) { + case Cubit::e_0th: + out_values.o (values.o () * values.o () * values.o ()); + break; + case Cubit::e_1st: + out_values.s (values.s () * values.s () * values.s ()); + break; + case Cubit::e_2nd: + out_values.l (values.l () * values.l () * values.l ()); + break; + case Cubit::e_3rd: + default: + out_values.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o ; + out_values.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s ; + out_values.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l ; + break; + } + return out_values; +} + +void Cubit_Impl:: please_exit (CORBA::Environment &) throw (CORBA::SystemException) { +} + +Cubit_ptr Cubit_Factory_Impl:: create_cubit (const char * name, CORBA::Environment &) throw (CORBA::SystemException) { + cerr << "Creating Cubit for " << name << endl; + +#ifdef Cubit_USE_BOA + Cubit_Impl_Task *cubit = new Cubit_Impl_Task (); +#else + Cubit_Impl_Task *cubit = new TIE_Cubit (Cubit_Impl) (new Cubit_Impl_Task); +#endif + Cubit::_duplicate ((Cubit *)cubit); + cubit->activate (1); + return (Cubit *) cubit; +} + +int +Cubit_Impl_Task::svc (void) +{ + while (1) + { + // Dequeue message + ACE_Message_Block *mb; + this->msg_queue ()->dequeue_head (mb); + CORBA::Request *vp = (CORBA::Request *) mb->base (); + mb->release (); + // Hand it off to Orbix + CORBA::Orbix.continueThreadDispatch (*vp); + } + return 0; +} + +void * +Cubit_Impl_Task::_deref (void) +{ + return this; +} diff --git a/TAO/performance-tests/Cubit/Orbix/tps/cubit_impl.h b/TAO/performance-tests/Cubit/Orbix/tps/cubit_impl.h new file mode 100644 index 00000000000..0fea9857af3 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/cubit_impl.h @@ -0,0 +1,48 @@ +// $Id$ + + +#ifndef cubit_ih +#define cubit_ih + +#include "cubit.h" +#include "ace/Task.h" + +#ifdef Cubit_USE_BOA +class Cubit_Impl : public virtual CubitBOAImpl { +#else +class Cubit_Impl { +#endif /* Cubit_USE_BOA */ +public: + virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + virtual void please_exit (CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); + +}; + +#ifdef Cubit_USE_BOA +class Cubit_Factory_Impl : public virtual Cubit_FactoryBOAImpl { +#else +class Cubit_Factory_Impl { +#endif + +public: + virtual Cubit_ptr create_cubit (const char * name, CORBA::Environment &IT_env=CORBA::default_environment) throw (CORBA::SystemException); +}; + +class Cubit_Impl_Task : public virtual Cubit_Impl, public virtual ACE_Task<ACE_MT_SYNCH> { +public: + // For ACE_Task + int svc (void); + // for narrowing + virtual void *_deref (); +}; + +#ifndef Cubit_USE_BOA +DEF_TIE_Cubit (Cubit_Impl) +DEF_TIE_Cubit_Factory (Cubit_Factory_Impl) +#endif /* Cubit_USE_BOA */ + +#endif diff --git a/TAO/performance-tests/Cubit/Orbix/tps/tps.cpp b/TAO/performance-tests/Cubit/Orbix/tps/tps.cpp new file mode 100644 index 00000000000..9ab83e9bc8d --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/tps.cpp @@ -0,0 +1,30 @@ +// $Id$ + +#include "tps.h" + +ACE_RCSID(tps, tps, "$Id$") + +int +TPS_Filter::inRequestPreMarshal(CORBA::Request &r, CORBA::Environment& env) +{ + // Get target + CORBA::Object_ptr obj = r.target (); + Cubit * cb = Cubit::_narrow (obj, env); + + if (env) // Not for our object!! + return 1; // continue in the same thread + + // Enqueue the request + Cubit_Impl_Task *ct; + if (CORBA::is_nil (cb)) + return 1; + ct = (Cubit_Impl_Task *) DEREF(cb); + if (ct) { + ACE_Message_Block *mb = new ACE_Message_Block ( (char *) (&r)); + ct->msg_queue ()->enqueue (mb); + } + // Done + return -1; +} + +TPS_Filter tps_filter; diff --git a/TAO/performance-tests/Cubit/Orbix/tps/tps.h b/TAO/performance-tests/Cubit/Orbix/tps/tps.h new file mode 100644 index 00000000000..362c9ed4e91 --- /dev/null +++ b/TAO/performance-tests/Cubit/Orbix/tps/tps.h @@ -0,0 +1,13 @@ +// $Id$ + +#include "cubit.h" +#include "cubit_impl.h" +#include "ace/Service_Config.h" +#include "ace/Thread_Manager.h" +#include "ace/Task.h" + +class TPS_Filter : public ACE_Task<ACE_MT_SYNCH>, public CORBA::ThreadFilter +{ +public: + virtual int inRequestPreMarshal(CORBA::Request &, CORBA::Environment&); +}; diff --git a/TAO/performance-tests/Cubit/README b/TAO/performance-tests/Cubit/README new file mode 100644 index 00000000000..218935ebfad --- /dev/null +++ b/TAO/performance-tests/Cubit/README @@ -0,0 +1,4 @@ +This directory contains performance tests for COOL, CORBAplus, +Hardpack, Orbix, TAO, and VisiBroker. These tests measure the +latency, jitter, CPU utilization, and priority inversion of these +ORBs. diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/DII_Cubit.dsw b/TAO/performance-tests/Cubit/TAO/DII_Cubit/DII_Cubit.dsw new file mode 100644 index 00000000000..3e83cd1bc20 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/DII_Cubit.dsw @@ -0,0 +1,29 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "client"=.\client.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/Makefile b/TAO/performance-tests/Cubit/TAO/DII_Cubit/Makefile new file mode 100644 index 00000000000..cfed0d87bce --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/Makefile @@ -0,0 +1,324 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +DIRS = ../IDL_Cubit + +LDLIBS = ../IDL_Cubit/.obj/cubitC.o \ + ../IDL_Cubit/.obj/cubitS.o \ + -lorbsvcs -lTAO + +PROG_SRCS = client.cpp + +LSRC = $(PROG_SRCS) + +CUBIT_CLT_OBJS = client.o + +CFLAGS += -I../IDL_Cubit + +BIN = client +BUILD = $(BIN) ../IDL_Cubit/server +VLDLIBS = $(LDLIBS:%=%$(VAR)) +VBIN = $(BIN:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +LDFLAGS += -L$(TAO_ROOT)/orbsvcs/orbsvcs \ + -L$(TAO_ROOT)/tao \ + -L$(TAO_ROOT)/orbsvcs/Naming_Service + +CPPFLAGS += -I$(TAO_ROOT)/orbsvcs + +.PRECIOUS: cubitC.cpp cubitS.cpp cubitC.h cubitS.h + +client: $(addprefix $(VDIR),$(CUBIT_CLT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + +../IDL_Cubit/server: + cd ../IDL_Cubit; $(MAKE) BUILD=server + +realclean: clean + -/bin/rm -rf cubitC.* cubitS.* cubitS_T.* + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/client.o .obj/client.so .shobj/client.o .shobj/client.so: client.cpp \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + $(ACE_ROOT)/ace/Env_Value_T.h \ + $(ACE_ROOT)/ace/Env_Value_T.i \ + $(ACE_ROOT)/ace/Env_Value_T.cpp \ + $(ACE_ROOT)/ace/Read_Buffer.h \ + $(ACE_ROOT)/ace/Read_Buffer.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/orbsvcs_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/CosNaming_i.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Entries.h \ + ../IDL_Cubit/cubitC.h ../IDL_Cubit/cubitC.i + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/README b/TAO/performance-tests/Cubit/TAO/DII_Cubit/README new file mode 100644 index 00000000000..1ca7a98a2fe --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/README @@ -0,0 +1,46 @@ +// $Id$ + +This is the cubit example that does everything using DII requests. +It uses the server in IDL_Cubit. The initial call to resolve the +nameservice is made on the orb. After that, getting a reference +to the Cubit object, making the Cubit operation calls, +and shutting down the server are all done with DII requests. + +To run the tests with one "button-push", execute the perl script run_test.pl +in this directory. It will start up the server and client. The client will +shut down the server when the tests are finished. + +If you want to run each executable separately and manually, run the +server first (in IDL_Cubit). Then run the client with zero or more of +the following args: + + [-d] Increments TAO_debug_level. It's additive, up + to 2 levels of debugging. + + [-n <calls/loop>] Sets the # of calls per loop (default is 250). + + [-i <factory IOR>] For passing the IOR by hand. + + [-f <filename>] If server is run with [-o <filename>] option, + it outputs its factory IOR to a file, which + the client can readwith this option. + + [-x] Shuts down server when finished. + + [-s] Disables use of the TAO naming service (-i and + -f options do this automatically). + +If using the -i option, you might want to run the server with the option +[-ORBobjrefstyle url]. This will cause the server to display its IOR in a +more human-readable form. Make sure you use the factory IOR, NOT the nameservice +IOR. The server displays both. The server can be run in the same window in the +background, or in a different window. + +The command line options, default calls per loop, order and display format of the +stats are all similar to those in the IDL_Cubit tests. + +On the Unix side, the Makefile will also build IDL_Cubit/server if +necessary (thanks to David Levine). If the server exits when run on a +Unix machine, it probbly means that someone else is also running it +and the defaults port numbers have collided. Just add the arg +[-ORBport 0] when running the server and it will get a new port number. diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp new file mode 100644 index 00000000000..87ca3963316 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.cpp @@ -0,0 +1,1063 @@ +// $Id$ + + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/Cubit/TAO/DII_Cubit +// +// = FILENAME +// client.cpp +// +// = DESCRIPTION +// This class implements a simple CORBA client of the Cubit +// interface using DII functionality. +// +// = AUTHOR +// Jeff Parsons <jp4@cs.wustl.edu> +// +// ============================================================================ + +#include "tao/corba.h" +#include "ace/streams.h" +#include "ace/Profile_Timer.h" +#include "ace/Get_Opt.h" +#include "ace/Env_Value_T.h" +#include "ace/Read_Buffer.h" +#include "orbsvcs/CosNamingC.h" +#include "orbsvcs/Naming/Naming_Utils.h" + +// Since we don't yet have an interface repository or dynamic-Any, we +// just get the info from the IDL-generated files, since we're mainly +// interested in timing comparisons anyway. +#include "../IDL_Cubit/cubitC.h" + +ACE_RCSID(DII_Cubit, client, "$Id$") + + // Some constants used below. + const CORBA::ULong DEFAULT_LOOP_COUNT = 250; +const char *DEFAULT_FACTORY_IOR = "ior00"; +const int SMALL_OCTET_SEQ_LENGTH = 16; +const int LARGE_OCTET_SEQ_LENGTH = 4096; +const int SMALL_LONG_SEQ_LENGTH = 4; +const int LARGE_LONG_SEQ_LENGTH = 1024; +const int NUMBER_OF_TESTS = 10; + +// Some macros for env checks used identically in each operation. +#define CUBIT_CHECK_ENV_RETURN_VOID(PRINT_STRING) \ +if (this->env_.exception () != 0) \ +{ \ + this->error_count_++; \ + this->env_.print_exception (PRINT_STRING); \ + return; \ +} + +#define CUBIT_CHECK_ENV_RELEASE_RETURN_VOID(REQ, PRINT_STRING) \ +if (this->env_.exception () != 0) \ +{ \ + this->error_count_++; \ + this->env_.print_exception (PRINT_STRING); \ + CORBA::release (REQ); \ + return; \ +} + +#define REQUEST_CHECK_ENV_RETURN_VOID(REQ, PRINT_STRING) \ +if (REQ->env ()->exception () != 0) \ +{ \ + this->error_count_++; \ + REQ->env ()->print_exception (PRINT_STRING); \ + CORBA::release (REQ); \ + return; \ +} + +class DII_Cubit_Client +{ + // = TITLE + // Defines a class that encapsulates behaviour of a Cubit client + // that makes requests using DII rather than stubs. + // + // = DESCRIPTION + // This class declares an interface to run an example client for + // a Cubit CORBA server. All the complexity for initializing the + // client is hidden in the class. Just the run() interface is + // needed. +public: + // = Constructor and destructor. + DII_Cubit_Client (void); + // Constructor. + + ~DII_Cubit_Client (void); + // Destructor. + + int init (int argc, char **argv); + // Initialize the ORB and gets the Cubit objref. + + int run (void); + // Execute client example code. + +private: + int init_naming_service (void); + // Gets objref through naming service. + + int parse_args (void); + // Parses the arguments passed on the command line. + + int read_ior (char *filename); + // Function to read the cubit factory IOR from a file. + + void print_stats (const char *call_name, + ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time); + // Prints the timing stats. + + // = DII versions of Cubit operations: + + void cube_short_dii (void); + void cube_long_dii (void); + void cube_octet_dii (void); + void cube_union_dii (void); + void cube_struct_dii (void); + void cube_octet_seq_dii (int length); + void cube_long_seq_dii (int length); + + // = Wrappers for cubing small and large sequences w/o args: + + void cube_small_long_seq (void); + void cube_large_long_seq (void); + void cube_small_octet_seq (void); + void cube_large_octet_seq (void); + void cube_mixin (void); + // Wrapper for the mixin call, just to be neat. + + void (DII_Cubit_Client::*op_array_[NUMBER_OF_TESTS])(void); + // Array of pointers to the operation functions. + + static char *stats_messages_[]; + // Array of labels for passing to print_stats. + + int argc_; + // # of arguments on the command line. + + char **argv_; + // arguments from command line. + + CORBA::ULong loop_count_; + // # of calls in test loop. + + int shutdown_; + // Flag to tell server to exit. + + int use_naming_service_; + // Flag toggling use of naming service to get IOR. + + CORBA::Environment env_; + // Environment variable. + + CORBA::ORB_var orb_var_; + // Storage of the ORB reference. + + CORBA::Object_var factory_var_; + // Storage of the Cubit_factory objref + + CORBA::Object_var obj_var_; + // Storage of the Cubit objref. + + CORBA::ULong call_count_; + // # of calls made to functions. + + CORBA::ULong error_count_; + // # of errors incurred in the lifetime of the application. + + char *factory_IOR_; + // IOR of the factory used to make a Cubit object. + + FILE *cubit_factory_ior_file_; + // File from which to obtain the IOR. + + ACE_HANDLE f_handle_; + // File handle to read the IOR. + + TAO_Naming_Client my_name_client_; + // An instance of the name client used for resolving the factory + // objects. +}; + +// Constructor +DII_Cubit_Client::DII_Cubit_Client (void) + : loop_count_ (DEFAULT_LOOP_COUNT), + shutdown_ (0), + use_naming_service_ (1), + orb_var_ (0), + factory_var_ (CORBA::Object::_nil ()), + obj_var_ (CORBA::Object::_nil ()), + call_count_ (0), + error_count_ (0), + factory_IOR_ (CORBA::string_dup (DEFAULT_FACTORY_IOR)) +{ + // Initialize the array of pointers-to-member-functions. + this->op_array_[0] = &DII_Cubit_Client::cube_short_dii; + this->op_array_[1] = &DII_Cubit_Client::cube_octet_dii; + this->op_array_[2] = &DII_Cubit_Client::cube_long_dii; + this->op_array_[3] = &DII_Cubit_Client::cube_struct_dii; + this->op_array_[4] = &DII_Cubit_Client::cube_union_dii; + this->op_array_[5] = &DII_Cubit_Client::cube_small_long_seq; + this->op_array_[6] = &DII_Cubit_Client::cube_large_long_seq; + this->op_array_[7] = &DII_Cubit_Client::cube_small_octet_seq; + this->op_array_[8] = &DII_Cubit_Client::cube_large_octet_seq; + this->op_array_[9] = &DII_Cubit_Client::cube_mixin; +} + +// Destructor +DII_Cubit_Client::~DII_Cubit_Client (void) +{ + CORBA::string_free (this->factory_IOR_); +} + +// An array of messages to pass to print_stats, so we can step through +// this along with op_array_. +char *DII_Cubit_Client::stats_messages_[] = +{ + "DII cube_short", + "DII cube_octet", + "DII cube_long", + "DII cube_struct", + "DII cube_union", + "DII cube_small_sequence<long>", + "DII cube_large_sequence<long>", + "DII cube_small_sequence<octet>", + "DII cube_large_sequence<octet>", + "DII cube mixin (short/octet/long)" +}; + +int +DII_Cubit_Client::init (int argc, char **argv) +{ + // Nice and safe. + this->argc_ = argc; + this->argv_ = argv; + + // Exits gracefully when no IOR is provided and use_naming_service_ + // is toggled off. + if (!ACE_OS::strcmp (this->factory_IOR_, + DEFAULT_FACTORY_IOR) + && !this->use_naming_service_) + ACE_ERROR_RETURN ((LM_ERROR, + "%s: Must supply IOR, read it from a file, or use naming service." + "\n", + this->argv_ [0]), + -1); + + TAO_TRY + { + // Initialize the ORB. + this->orb_var_ = CORBA::ORB_init (this->argc_, + this->argv_, + "internet", + TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Parse command line and verify parameters. + if (this->parse_args () == -1) + return -1; + + if (this->use_naming_service_) + { + // Get a factory object reference from the naming service. + if (this->init_naming_service () == -1) + return -1; + } + else + { + // Get a factory object reference from the factory IOR. + this->factory_var_ = + this->orb_var_->string_to_object (this->factory_IOR_, + TAO_TRY_ENV); + TAO_CHECK_ENV; + } + + // Get a Cubit object with a DII request on the Cubit factory. + CORBA::Request_ptr mc_req = + this->factory_var_->_request ("make_cubit", TAO_TRY_ENV); + + TAO_CHECK_ENV; + + // make_cubit takes a char* arg that it doesn't use, but we must + // still include it in the request. + CORBA::String dummy = ""; + + CORBA::Any string_arg (CORBA::_tc_string, + &dummy, + 0); + + // @@ Jeff, is it possible to use the operator<< for this in + // order to simplify the code? + mc_req->arguments ()->add_value (0, + string_arg, + CORBA::ARG_IN, + TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Insert the result-holding variable into the request. + mc_req->result ()->value ()->replace (CORBA::_tc_Object, + &this->obj_var_, + 0, + TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Invoke the <make_cubit> operation to ask the Cubit factory + // for a Cubit object. + mc_req->invoke (); + + CORBA::release (mc_req); + + if (CORBA::is_nil (this->obj_var_.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " could not obtain Cubit object from Cubit factory <%s>\n"), + -1); + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("DII_Cubit_Client::init"); + return -1; + } + TAO_ENDTRY; + + return 0; +} + +// Get the factory IOR via a DII request on the naming service. + +int +DII_Cubit_Client::init_naming_service (void) +{ + TAO_TRY + { + // Initialize the naming services + if (my_name_client_.init (orb_var_.in (), argc_, argv_) != 0) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize " + "the TAO_Naming_Client. \n"), + -1); + /* + // Get the naming service from the orb. + CORBA::Object_var naming_obj = + this->orb_var_->resolve_initial_references ("NameService"); + + if (CORBA::is_nil (naming_obj.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to resolve the Name Service.\n"), + -1); + */ + + // Build a Name object. + CosNaming::Name cubit_factory_name (2); + cubit_factory_name.length (2); + cubit_factory_name[0].id = CORBA::string_dup ("IDL_Cubit"); + cubit_factory_name[1].id = CORBA::string_dup ("cubit_factory"); + + // Build up the <resolve> operation using the DII! + CORBA::Request_ptr req = + my_name_client_->_request ("resolve", TAO_TRY_ENV); + + TAO_CHECK_ENV; + + CORBA::Any name_arg (CosNaming::_tc_Name, + &cubit_factory_name, + 0); + + req->arguments ()->add_value (0, + name_arg, + CORBA::ARG_IN, + TAO_TRY_ENV); + TAO_CHECK_ENV; + + req->result ()->value ()->replace (CORBA::_tc_Object, + &this->factory_var_, + 0, + TAO_TRY_ENV); + TAO_CHECK_ENV; + + req->invoke (); + CORBA::release (req); + + if (CORBA::is_nil (this->factory_var_.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " could not resolve cubit factory in Naming service <%s>\n"), + -1); + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("DII_Cubit_Client::init_naming_service"); + return -1; + } + TAO_ENDTRY; + + return 0; +} + +// Sort out the args in the command line. + +int +DII_Cubit_Client::parse_args (void) +{ + ACE_Get_Opt opts (argc_, argv_, "dn:i:f:xs"); + int c; + int result; + + while ((c = opts ()) != -1) + switch (c) + { + case 'd': // debug flag + TAO_debug_level++; + break; + case 'n': // loop count + this->loop_count_ = ACE_OS::atoi (opts.optarg); + break; + case 'i': // Get the IOR from the command line. + this->use_naming_service_ = 0; + this->factory_IOR_ = opts.optarg; + break; + case 'f': // Read the IOR from the file. + this->use_naming_service_ = 0; + result = this->read_ior (opts.optarg); + if (result < 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to read ior from %s : %p\n", + opts.optarg), + -1); + break; + case 'x': // Shut down server after test run. + this->shutdown_ = 1; + break; + case 's': // Don't use the TAO naming service. + this->use_naming_service_ = 0; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-d]" + " [-n calls/loop]" + " [-i cubit-factory-IOR]" + " [-f filename]" + " [-x]" + " [-s]" + "\n", + this->argv_ [0]), + -1); + } + return 0; // Indicates successful parsing of command line. +} + +// Get the factory IOR from the file created by the server. +int +DII_Cubit_Client::read_ior (char *filename) +{ + // Open the file for reading. + this->f_handle_ = ACE_OS::open (filename,0); + + if (this->f_handle_ == ACE_INVALID_HANDLE) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to open %s for writing: %p\n", + filename), + -1); + ACE_Read_Buffer ior_buffer (this->f_handle_); + this->factory_IOR_ = ior_buffer.read (); + + if (this->factory_IOR_ == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to allocate memory to read ior: %p\n"), + -1); + return 0; +} + +// Formats and prints time statistics. Identical to function in +// IDL_Cubit, for ease of comparison. + +void +DII_Cubit_Client::print_stats (const char *call_name, + ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time) +{ + ACE_DEBUG ((LM_DEBUG, + "%s:\n", + call_name)); + + if (this->call_count_ > 0 + && this->error_count_ == 0) + { +#if defined (ACE_LACKS_FLOATING_POINT) + // elapsed_time.real_time is in units of microseconds. + const u_int calls_per_sec = + this->call_count_ * 1000000u / elapsed_time.real_time; + + ACE_DEBUG ((LM_DEBUG, + "\treal_time\t= %u ms,\n" + "\t%u calls/second\n", + elapsed_time.real_time / 1000u, + calls_per_sec)); +#else /* ! ACE_LACKS_FLOATING_POINT */ + // elapsed_time.real_time is in units of seconds. + double calls_per_sec = + this->call_count_ / elapsed_time.real_time; + + ACE_DEBUG ((LM_DEBUG, + "\treal_time\t= %0.06f ms, \n\t" + "user_time\t= %0.06f ms, \n\t" + "system_time\t= %0.06f ms\n" + "\t%0.00f calls/second\n", + elapsed_time.real_time < 0.0 ? 0.0 + : elapsed_time.real_time * ACE_ONE_SECOND_IN_MSECS, + elapsed_time.user_time < 0.0 ? 0.0 + : elapsed_time.user_time * ACE_ONE_SECOND_IN_MSECS, + elapsed_time.system_time < 0.0 ? 0.0 + : elapsed_time.system_time * ACE_ONE_SECOND_IN_MSECS, + calls_per_sec < 0.0 ? 0.0 : calls_per_sec)); +#endif /* ! ACE_LACKS_FLOATING_POINT */ + } + else + ACE_ERROR ((LM_ERROR, + "\tNo time stats printed. " + "Call count zero or error ocurred.\n")); + + ACE_DEBUG ((LM_DEBUG, + "\t%d calls, %d errors\n", + this->call_count_, + this->error_count_)); +} + +void +DII_Cubit_Client::cube_short_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req; + + req = this->obj_var_->_request ("cube_short", + this->env_); + + CUBIT_CHECK_ENV_RETURN_VOID ("cube_short_dii request create"); + + CORBA::Short ret_short = 0; + CORBA::Short arg_short = -3; + + // Make an Any out of the short and add it to the request arg list. + CORBA::Any arg_holder (CORBA::_tc_short, + &arg_short, + 0); + + req->arguments ()->add_value (0, + arg_holder, + CORBA::ARG_IN, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_short_dii request arg add"); + + // Initialize the result variable. + req->result ()->value ()->replace (CORBA::_tc_short, + &ret_short, + 0, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_short_dii result type"); + + // Invoke, check for an exception and verify the result. + + this->call_count_++; + + req->invoke (); + + REQUEST_CHECK_ENV_RETURN_VOID (req, + "cube_short_dii invoke"); + + if (ret_short != arg_short * arg_short * arg_short) + { + ACE_ERROR ((LM_ERROR, + "cube_short_dii -- bad results\n")); + this->error_count_++; + } + + CORBA::release (req); +} + +void +DII_Cubit_Client::cube_long_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req; + + req = this->obj_var_->_request ("cube_long", + this->env_); + + CUBIT_CHECK_ENV_RETURN_VOID ("cube_long_dii request create"); + + CORBA::Long ret_long = 0; + CORBA::Long arg_long = -7; + + // Make an Any out of the long and add it to the request arg list. + CORBA::Any arg_holder (CORBA::_tc_long, + &arg_long, + 0); + + req->arguments ()->add_value (0, + arg_holder, + CORBA::ARG_IN, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_long_dii request arg add"); + + // Insert the result variable. + req->result ()->value ()->replace (CORBA::_tc_long, + &ret_long, + 0, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_long_dii result type"); + + // Invoke, check for an exception and verify the result. + + this->call_count_++; + + req->invoke (); + + REQUEST_CHECK_ENV_RETURN_VOID (req, + "cube_long_dii invoke"); + + if (ret_long != arg_long * arg_long * arg_long) + { + ACE_ERROR ((LM_ERROR, + "cube_long_dii -- bad results\n")); + this->error_count_++; + } + + CORBA::release (req); +} + +void +DII_Cubit_Client::cube_octet_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req; + + req = this->obj_var_->_request ("cube_octet", + this->env_); + + CUBIT_CHECK_ENV_RETURN_VOID ("cube_octet_dii request create"); + + CORBA::Octet ret_octet = 0; + CORBA::Octet arg_octet = 5; + + // Make an Any out of the octet and add it to the request arg list. + CORBA::Any arg_holder (CORBA::_tc_octet, + &arg_octet, + 0); + + req->arguments ()->add_value (0, + arg_holder, + CORBA::ARG_IN, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_octet_dii request arg add"); + + // Insert the result variable. + req->result ()->value ()->replace (CORBA::_tc_octet, + &ret_octet, + 0, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_octet_dii result type"); + + // Invoke, check for an exception and verify the result. + this->call_count_++; + + req->invoke (); + + REQUEST_CHECK_ENV_RETURN_VOID (req, + "cube_octet_dii invoke"); + + if (ret_octet != arg_octet * arg_octet * arg_octet) + { + ACE_ERROR ((LM_ERROR, + "cube_octet_dii -- bad results\n")); + this->error_count_++; + } + + CORBA::release (req); +} + +void +DII_Cubit_Client::cube_union_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req; + + req = this->obj_var_->_request ("cube_union", + this->env_); + + CUBIT_CHECK_ENV_RETURN_VOID ("cube_union_dii request create"); + + Cubit::oneof arg_union, ret_union; + + arg_union._d(Cubit::e_3rd); + arg_union.cm ().l = 5; + arg_union.cm ().s = -7; + arg_union.cm ().o = 3; + + // A different discrim value than arg_ret, just to be ornery. + ret_union._d(Cubit::e_1st); + ret_union.s (0); + + // Make an Any out of the union and add it to the request arg list. + CORBA::Any arg_holder (Cubit::_tc_oneof, + &arg_union, + 0); + + req->arguments ()->add_value (0, + arg_holder, + CORBA::ARG_IN, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_union_dii request arg add"); + + // Insert the result variable. + req->result ()->value ()->replace (Cubit::_tc_oneof, + &ret_union, + 0, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_union_dii result type"); + + // Invoke, check for an exception and verify the result + + this->call_count_++; + + req->invoke (); + + REQUEST_CHECK_ENV_RETURN_VOID (req, "cube_union_dii invoke"); + + if (ret_union.cm ().l != arg_union.cm ().l * arg_union.cm ().l * arg_union.cm ().l + || ret_union.cm ().s != arg_union.cm ().s * arg_union.cm ().s * arg_union.cm ().s + || ret_union.cm ().o != arg_union.cm ().o * arg_union.cm ().o * arg_union.cm ().o) + { + ACE_ERROR ((LM_ERROR, + "cube_union_dii -- bad results\n")); + this->error_count_++; + } + + CORBA::release (req); +} + +void +DII_Cubit_Client::cube_struct_dii (void) +{ + // Create the request ... + CORBA::Request_ptr req; + + req = this->obj_var_->_request ("cube_struct", + this->env_); + + CUBIT_CHECK_ENV_RETURN_VOID ("cube_struct_dii request create"); + + Cubit::Many arg_struct, ret_struct; + + ret_struct.l = 0; + ret_struct.s = 0; + ret_struct.o = 0; + + arg_struct.l = 5; + arg_struct.s = -7; + arg_struct.o = 3; + + // Make an Any out of the struct and add it to the request arg list. + CORBA::Any arg_holder (Cubit::_tc_Many, + &arg_struct, + 0); + + req->arguments ()->add_value (0, + arg_holder, + CORBA::ARG_IN, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_struct_dii request arg add"); + + // Insert the result variable. + req->result ()->value ()->replace (Cubit::_tc_Many, + &ret_struct, + 0, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_struct_dii result type"); + + // Invoke, check for an exception and verify the result. + + this->call_count_++; + + req->invoke (); + + REQUEST_CHECK_ENV_RETURN_VOID (req, "cube_struct_dii invoke"); + + if (ret_struct.l != arg_struct.l * arg_struct.l * arg_struct.l + || ret_struct.s != arg_struct.s * arg_struct.s * arg_struct.s + || ret_struct.o != arg_struct.o * arg_struct.o * arg_struct.o) + { + ACE_ERROR ((LM_ERROR, + "cube_struct_dii -- bad results\n")); + this->error_count_++; + } + + CORBA::release (req); +} + +void +DII_Cubit_Client::cube_octet_seq_dii (int length) +{ + // Create the request ... + CORBA::Request_ptr req; + + req = this->obj_var_->_request ("cube_octet_sequence", + this->env_); + + CUBIT_CHECK_ENV_RETURN_VOID ("cube_octet_seq_dii request create"); + + // Same length as in IDL_Cubit tests so timings can be compared. + // Return value holder is set to a different length to test resizing. + Cubit::octet_seq ret_octet_seq (1), arg_octet_seq (length); + arg_octet_seq.length (length); + arg_octet_seq[0] = 4; + ret_octet_seq[0] = 0; + + // Make an Any out of the octet_seq and add it to the request arg list + CORBA::Any arg_holder (Cubit::_tc_octet_seq, + &arg_octet_seq, + 0); + + req->arguments ()->add_value (0, + arg_holder, + CORBA::ARG_IN, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_octet_seq_dii request arg add"); + + // Insert the result variable. + req->result ()->value ()->replace (Cubit::_tc_octet_seq, + &ret_octet_seq, + 0, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_octet_seq_dii result type"); + + // Invoke, check for an exception and verify the result. + + this->call_count_++; + + req->invoke (); + + REQUEST_CHECK_ENV_RETURN_VOID (req, + "cube_octet_seq_dii invoke"); + + // Check for correct length. + if (ret_octet_seq.length () != arg_octet_seq.length ()) + { + ACE_ERROR ((LM_ERROR, + "cube_octet_seq_dii -- bad length\n")); + this->error_count_++; + } + + // Check for correct value(s). + if (ret_octet_seq[0] != arg_octet_seq[0] * arg_octet_seq[0] * arg_octet_seq[0]) + { + ACE_ERROR ((LM_ERROR, + "cube_octet_seq_dii -- bad results\n")); + this->error_count_++; + } + + CORBA::release (req); +} + +void +DII_Cubit_Client::cube_long_seq_dii (int length) +{ + // Create the request ... + CORBA::Request_ptr req; + + req = this->obj_var_->_request ("cube_long_sequence", + this->env_); + + CUBIT_CHECK_ENV_RETURN_VOID ("cube_long_seq_dii request create"); + + // Same length as in IDL_Cubit tests so timings can be compared. + // Return value holder is set to a different length to test + // resizing. + Cubit::long_seq ret_long_seq (1); + Cubit::long_seq arg_long_seq (length); + arg_long_seq.length (length); + arg_long_seq[0] = 4; + ret_long_seq[0] = 0; + + // Make an Any out of the long_seq and add it to the request arg + // list. + CORBA::Any arg_holder (Cubit::_tc_long_seq, + &arg_long_seq, + 0); + + req->arguments ()->add_value (0, + arg_holder, + CORBA::ARG_IN, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_long_seq_dii request arg add"); + + // Insert the result variable. + req->result ()->value ()->replace (Cubit::_tc_long_seq, + &ret_long_seq, + 0, + this->env_); + + CUBIT_CHECK_ENV_RELEASE_RETURN_VOID (req, + "cube_long_seq_dii result type"); + + // Invoke, check for an exception and verify the result. + + this->call_count_++; + + req->invoke (); + + REQUEST_CHECK_ENV_RETURN_VOID (req, + "cube_long_seq_dii invoke"); + + // Check for correct length. + if (ret_long_seq.length () != arg_long_seq.length ()) + { + ACE_ERROR ((LM_ERROR, + "cube_long_seq_dii -- bad length\n")); + this->error_count_++; + } + + // Check for correct value(s). + if (ret_long_seq[0] != arg_long_seq[0] * arg_long_seq[0] * arg_long_seq[0]) + { + ACE_ERROR ((LM_ERROR, + "cube_long_seq_dii -- bad results\n")); + this->error_count_++; + } + + CORBA::release (req); +} + +// Wrappers for operations with non-void arg lists and the 3-in-1 +// mixin test, so an array of pointers to functions can be stepped +// through in run (). + +void +DII_Cubit_Client::cube_small_long_seq (void) +{ + this->cube_long_seq_dii (SMALL_LONG_SEQ_LENGTH); +} + +void +DII_Cubit_Client::cube_large_long_seq (void) +{ + this->cube_long_seq_dii (LARGE_LONG_SEQ_LENGTH); +} + +void +DII_Cubit_Client::cube_small_octet_seq (void) +{ + this->cube_octet_seq_dii (SMALL_OCTET_SEQ_LENGTH); +} + +void +DII_Cubit_Client::cube_large_octet_seq (void) +{ + this->cube_octet_seq_dii (LARGE_OCTET_SEQ_LENGTH); +} + +void +DII_Cubit_Client::cube_mixin (void) +{ + this->cube_short_dii (); + this->cube_octet_dii (); + this->cube_long_dii (); +} + +int +DII_Cubit_Client::run (void) +{ + // loop counter. + CORBA::ULong i; + + // Make a timer and an elapsed time holder. + ACE_Profile_Timer dii_timer; + ACE_Profile_Timer::ACE_Elapsed_Time dii_elapsed_time; + + // Order and format of test calls matches that of SII (IDL) tests + // for easy comparison. + + for (int j = 0; j < NUMBER_OF_TESTS; j++) + { + this->call_count_ = 0; + this->error_count_ = 0; + dii_timer.start (); + + for (i = 0; i < this->loop_count_; i++) + (this->*op_array_[j])(); + + dii_timer.stop (); + dii_timer.elapsed_time (dii_elapsed_time); + this->print_stats (this->stats_messages_[j], dii_elapsed_time); + } + + TAO_TRY + { + // Shut down server via a DII request. + if (this->shutdown_) + { + CORBA::Request_ptr req; + + req = this->obj_var_->_request ("shutdown", + TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Cubit::shutdown () is a oneway operation. + req->send_oneway (); + + CORBA::release (req); + + ACE_DEBUG ((LM_DEBUG, + "\n\t Shutting down IDL_Cubit server \n\n")); + } + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("DII_Cubit_Client: server shutdown"); + return -1; + } + TAO_ENDTRY; + + return this->error_count_ == 0 ? 0 : 1; +} + +// Start the test. + +int main (int argc, char *argv[]) +{ + DII_Cubit_Client cubit_client; + + ACE_DEBUG ((LM_DEBUG, + "\n\t DII_Cubit::CLIENT \n\n")); + + if (cubit_client.init (argc, argv) == -1) + return 1; + + return cubit_client.run (); +} diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.dsp b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.dsp new file mode 100644 index 00000000000..4ab257a8507 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/client.dsp @@ -0,0 +1,125 @@ +# Microsoft Developer Studio Project File - Name="DII_Cubit Client" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=DII_Cubit Client - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak" CFG="DII_Cubit Client - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "DII_Cubit Client - Win32 Release" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE "DII_Cubit Client - Win32 Debug" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "DII_Cubit Client - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\client\Release"
+# PROP BASE Intermediate_Dir ".\client\Release"
+# PROP BASE Target_Dir ".\client"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ".\client"
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\IDL_Cubit" /I "..\..\..\..\orbsvcs" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 TAO.lib ace.lib orbsvcs.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\tao" /libpath:"..\..\..\..\..\ace" /libpath:"..\..\..\..\orbsvcs\orbsvcs"
+
+!ELSEIF "$(CFG)" == "DII_Cubit Client - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\client\Debug"
+# PROP BASE Intermediate_Dir ".\client\Debug"
+# PROP BASE Target_Dir ".\client"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ".\client"
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\IDL_Cubit" /I "..\..\..\..\orbsvcs" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D TAO_ORBSVCS_HAS_DLL=1 /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+# ADD LINK32 TAOd.lib aced.lib orbsvcsd.lib /nologo /subsystem:console /debug /machine:I386 /libpath:"..\..\..\..\tao" /libpath:"..\..\..\..\..\ace" /libpath:"..\..\..\..\orbsvcs\orbsvcs"
+
+!ENDIF
+
+# Begin Target
+
+# Name "DII_Cubit Client - Win32 Release"
+# Name "DII_Cubit Client - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\IDL_Cubit\cubitC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\IDL_Cubit\cubitS.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\client.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\IDL_Cubit\cubitC.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\IDL_Cubit\cubitS.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;cnt;rtf;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/cubit.idl b/TAO/performance-tests/Cubit/TAO/DII_Cubit/cubit.idl new file mode 100644 index 00000000000..7f6e87ea8d8 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/cubit.idl @@ -0,0 +1,153 @@ +/* -*- C++ -*- */ +// $Id$ + +interface Cubit +{ + // = TITLE + // Defines an interface that encapsulates operations that cube + // numbers. + // + // = DESCRIPTION + // This interface encapsulates operations that cube + // octets, shorts, longs, structs and unions. + + oneway void cube_oneway (); + // Test the basic latency of a nil oneway operation. + + void cube_void (); + // Test the basic latency of a nil operation. + + octet cube_octet (in octet o); + // cube an octet + + short cube_short (in short s); + // cube a short + + long cube_long (in long l); + // cube a long + + struct Many + { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + // Cube a struct + + enum discrim + { + e_0th, + e_1st, + e_2nd, + e_3rd + }; + // Enumeration of the different elements in a union. + + union oneof switch (discrim) + { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + Many cm; + + // default: + // Many cm; + }; + // Union of different types. + + oneof cube_union (in oneof values); + // cube a union. + + typedef sequence<long> long_seq; + + void cube_long_sequence (in long_seq input, + out long_seq output); + // Cube several longs. + + + typedef sequence<octet> octet_seq; + void cube_octet_sequence (in octet_seq input, out octet_seq output); + // Cube an octet sequence. + + oneway void shutdown (); + // shutdown the application. + + // = The following types provide a torture-test for structs. + struct RtiPacketHeader + { + unsigned long packetLength; // this is probably redundant + unsigned short federationHandle; + unsigned long channelHandle; + unsigned long packetColor; + }; + + struct HandleValuePair + { + unsigned short handle; + octet_seq data; + }; + + enum MessageHeaderTypes + { + objectUpdate, + interaction + // others omitted + }; + + typedef sequence<HandleValuePair> HandleValuePairSeq; + struct RtiObjectUpdateMessageHeader + { + unsigned long updateLength; // probably redundant + unsigned long updateTag; + unsigned long objectHandle; + double timestamp; + unsigned long long eventRetractionHandle; + unsigned short classHandle; + unsigned short sendingFederateHandle; + string userTag; + octet_seq regionData; + octet transportationHandle; + octet orderingHandle; + HandleValuePairSeq messagePayload; + }; + + struct RtiInteractionMessageHeader + { + unsigned long updateLength; + // similar to object update + }; + + union MessageUnion switch(MessageHeaderTypes) + { + case objectUpdate: + RtiObjectUpdateMessageHeader oumh; + case interaction: + RtiInteractionMessageHeader imh; + }; + + typedef sequence <MessageUnion> MessageUnionSeq; + struct RtiPacket + { + RtiPacketHeader packetHeader; + MessageUnionSeq msgs; + }; + + void cube_rti_data (in RtiPacket input, + out RtiPacket output); +}; + +interface Cubit_Factory +{ + // = TITLE + // Creates Cubit objects. + + Cubit make_cubit (); +}; diff --git a/TAO/performance-tests/Cubit/TAO/DII_Cubit/run_test.pl b/TAO/performance-tests/Cubit/TAO/DII_Cubit/run_test.pl new file mode 100755 index 00000000000..6c50ed6517e --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/DII_Cubit/run_test.pl @@ -0,0 +1,33 @@ +#$Id$ +# -*- perl -*- +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +unshift @INC, '../../../../../bin'; +require Process; + +$client_port = 0; +$server_port = 0; +$iorfile = "theior"; +$sleeptime = 5; + +$SV = Process::Create ("..$DIR_SEPARATOR" + ."IDL_Cubit".$DIR_SEPARATOR. + "server".$Process::EXE_EXT. + " -ORBport ".$server_port. + " -ORBobjrefstyle url". + " -s -o $iorfile"); + +sleep $sleeptime; + +$status = system ("client".$Process::EXE_EXT. + " -ORBport $client_port". + " -s -f $iorfile -x"); + +# @@ TODO change to Wait() once the -x option works. +$SV->Kill (); $SV->Wait (); + +unlink $iorfile; + +exit $status; diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit.mak b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit.mak new file mode 100644 index 00000000000..3e27159faeb --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit.mak @@ -0,0 +1,2068 @@ +# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+!IF "$(CFG)" == ""
+CFG=client - Win32 Debug
+!MESSAGE No configuration specified. Defaulting to client - Win32 Debug.
+!ENDIF
+
+!IF "$(CFG)" != "server - Win32 Release" && "$(CFG)" != "server - Win32 Debug"\
+ && "$(CFG)" != "client - Win32 Release" && "$(CFG)" != "client - Win32 Debug"
+!MESSAGE Invalid configuration "$(CFG)" specified.
+!MESSAGE You can specify a configuration when running NMAKE on this makefile
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "Cubit.mak" CFG="client - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "server - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "server - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE "client - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "client - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+!ERROR An invalid configuration is specified.
+!ENDIF
+
+!IF "$(OS)" == "Windows_NT"
+NULL=
+!ELSE
+NULL=nul
+!ENDIF
+################################################################################
+# Begin Project
+# PROP Target_Last_Scanned "client - Win32 Debug"
+RSC=rc.exe
+CPP=cl.exe
+
+!IF "$(CFG)" == "server - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "server\Release"
+# PROP BASE Intermediate_Dir "server\Release"
+# PROP BASE Target_Dir "server"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir "server"
+OUTDIR=.
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\server.exe"
+
+CLEAN :
+ -@erase "$(INTDIR)\Cubit_Client.obj"
+ -@erase "$(INTDIR)\cubitC.obj"
+ -@erase "$(INTDIR)\cubitS.obj"
+ -@erase "$(INTDIR)\svr.obj"
+ -@erase "$(OUTDIR)\server.exe"
+ -@erase ".\cubitC.cpp"
+ -@erase ".\cubitC.h"
+ -@erase ".\cubitC.i"
+ -@erase ".\cubitS.cpp"
+ -@erase ".\cubitS.h"
+ -@erase ".\cubitS.i"
+
+"$(INTDIR)" :
+ if not exist "$(INTDIR)/$(NULL)" mkdir "$(INTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\
+ /Fp"$(INTDIR)/server.pch" /YX /Fo"$(INTDIR)/" /c
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/server.bsc"
+BSC32_SBRS= \
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ace.lib TAO.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+LINK32_FLAGS=ace.lib TAO.lib kernel32.lib user32.lib gdi32.lib winspool.lib\
+ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\
+ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no\
+ /pdb:"$(OUTDIR)/server.pdb" /machine:I386 /out:"$(OUTDIR)/server.exe"
+LINK32_OBJS= \
+ "$(INTDIR)\Cubit_Client.obj" \
+ "$(INTDIR)\cubitC.obj" \
+ "$(INTDIR)\cubitS.obj" \
+ "$(INTDIR)\svr.obj"
+
+"$(OUTDIR)\server.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+ $(LINK32) @<<
+ $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF "$(CFG)" == "server - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "server\Debug"
+# PROP BASE Intermediate_Dir "server\Debug"
+# PROP BASE Target_Dir "server"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir "server"
+OUTDIR=.
+INTDIR=.\Debug
+
+ALL : "$(OUTDIR)\server.exe"
+
+CLEAN :
+ -@erase "$(INTDIR)\Cubit_Client.obj"
+ -@erase "$(INTDIR)\cubitC.obj"
+ -@erase "$(INTDIR)\cubitS.obj"
+ -@erase "$(INTDIR)\svr.obj"
+ -@erase "$(INTDIR)\vc40.idb"
+ -@erase "$(INTDIR)\vc40.pdb"
+ -@erase "$(OUTDIR)\server.exe"
+ -@erase "$(OUTDIR)\server.ilk"
+ -@erase "$(OUTDIR)\server.pdb"
+ -@erase ".\cubitC.cpp"
+ -@erase ".\cubitC.h"
+ -@erase ".\cubitC.i"
+ -@erase ".\cubitS.cpp"
+ -@erase ".\cubitS.h"
+ -@erase ".\cubitS.i"
+
+"$(INTDIR)" :
+ if not exist "$(INTDIR)/$(NULL)" mkdir "$(INTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE"\
+ /Fp"$(INTDIR)/server.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c
+CPP_OBJS=.\Debug/
+CPP_SBRS=.\.
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/server.bsc"
+BSC32_SBRS= \
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+# ADD LINK32 aced.lib TAO.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+LINK32_FLAGS=aced.lib TAO.lib kernel32.lib user32.lib gdi32.lib winspool.lib\
+ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\
+ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:yes\
+ /pdb:"$(OUTDIR)/server.pdb" /debug /machine:I386 /out:"$(OUTDIR)/server.exe"
+LINK32_OBJS= \
+ "$(INTDIR)\Cubit_Client.obj" \
+ "$(INTDIR)\cubitC.obj" \
+ "$(INTDIR)\cubitS.obj" \
+ "$(INTDIR)\svr.obj"
+
+"$(OUTDIR)\server.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+ $(LINK32) @<<
+ $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF "$(CFG)" == "client - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "client\Release"
+# PROP BASE Intermediate_Dir "client\Release"
+# PROP BASE Target_Dir "client"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir "client"
+OUTDIR=.
+INTDIR=.\Release
+
+ALL : "$(OUTDIR)\client.exe"
+
+CLEAN :
+ -@erase "$(INTDIR)\clnt.obj"
+ -@erase "$(INTDIR)\cubitC.obj"
+ -@erase "$(OUTDIR)\client.exe"
+
+"$(INTDIR)" :
+ if not exist "$(INTDIR)/$(NULL)" mkdir "$(INTDIR)"
+
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE"\
+ /Fp"$(INTDIR)/client.pch" /YX /Fo"$(INTDIR)/" /c
+CPP_OBJS=.\Release/
+CPP_SBRS=.\.
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/client.bsc"
+BSC32_SBRS= \
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ace.lib TAO.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+LINK32_FLAGS=ace.lib TAO.lib kernel32.lib user32.lib gdi32.lib winspool.lib\
+ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\
+ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:no\
+ /pdb:"$(OUTDIR)/client.pdb" /machine:I386 /out:"$(OUTDIR)/client.exe"
+LINK32_OBJS= \
+ "$(INTDIR)\clnt.obj" \
+ "$(INTDIR)\cubitC.obj"
+
+"$(OUTDIR)\client.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+ $(LINK32) @<<
+ $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ELSEIF "$(CFG)" == "client - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "client\Debug"
+# PROP BASE Intermediate_Dir "client\Debug"
+# PROP BASE Target_Dir "client"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir "client"
+OUTDIR=.
+INTDIR=.\Debug
+
+ALL : "$(OUTDIR)\client.exe"
+
+CLEAN :
+ -@erase "$(INTDIR)\clnt.obj"
+ -@erase "$(INTDIR)\cubitC.obj"
+ -@erase "$(INTDIR)\vc40.idb"
+ -@erase "$(INTDIR)\vc40.pdb"
+ -@erase "$(OUTDIR)\client.exe"
+ -@erase "$(OUTDIR)\client.ilk"
+ -@erase "$(OUTDIR)\client.pdb"
+
+"$(INTDIR)" :
+ if not exist "$(INTDIR)/$(NULL)" mkdir "$(INTDIR)"
+
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE"\
+ /Fp"$(INTDIR)/client.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c
+CPP_OBJS=.\Debug/
+CPP_SBRS=.\.
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+BSC32_FLAGS=/nologo /o"$(OUTDIR)/client.bsc"
+BSC32_SBRS= \
+
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+# ADD LINK32 aced.lib TAO.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+LINK32_FLAGS=aced.lib TAO.lib kernel32.lib user32.lib gdi32.lib winspool.lib\
+ comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib\
+ odbc32.lib odbccp32.lib /nologo /subsystem:console /incremental:yes\
+ /pdb:"$(OUTDIR)/client.pdb" /debug /machine:I386 /out:"$(OUTDIR)/client.exe"
+LINK32_OBJS= \
+ "$(INTDIR)\clnt.obj" \
+ "$(INTDIR)\cubitC.obj"
+
+"$(OUTDIR)\client.exe" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS)
+ $(LINK32) @<<
+ $(LINK32_FLAGS) $(LINK32_OBJS)
+<<
+
+!ENDIF
+
+.c{$(CPP_OBJS)}.obj:
+ $(CPP) $(CPP_PROJ) $<
+
+.cpp{$(CPP_OBJS)}.obj:
+ $(CPP) $(CPP_PROJ) $<
+
+.cxx{$(CPP_OBJS)}.obj:
+ $(CPP) $(CPP_PROJ) $<
+
+.c{$(CPP_SBRS)}.sbr:
+ $(CPP) $(CPP_PROJ) $<
+
+.cpp{$(CPP_SBRS)}.sbr:
+ $(CPP) $(CPP_PROJ) $<
+
+.cxx{$(CPP_SBRS)}.sbr:
+ $(CPP) $(CPP_PROJ) $<
+
+################################################################################
+# Begin Target
+
+# Name "server - Win32 Release"
+# Name "server - Win32 Debug"
+
+!IF "$(CFG)" == "server - Win32 Release"
+
+!ELSEIF "$(CFG)" == "server - Win32 Debug"
+
+!ENDIF
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\svr.cpp
+DEP_CPP_SVR_C=\
+ ".\Cubit_Client.h"\
+ ".\cubitC.h"\
+ ".\cubitC.i"\
+ ".\cubitS.h"\
+ ".\cubitS.i"\
+ {$(INCLUDE)}"\ace\Acceptor.cpp"\
+ {$(INCLUDE)}"\ace\Acceptor.h"\
+ {$(INCLUDE)}"\ace\Acceptor.i"\
+ {$(INCLUDE)}"\ace\ACE.h"\
+ {$(INCLUDE)}"\ace\ACE.i"\
+ {$(INCLUDE)}"\ace\Addr.h"\
+ {$(INCLUDE)}"\ace\Addr.i"\
+ {$(INCLUDE)}"\ace\Atomic_Op.i"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.cpp"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.h"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.i"\
+ {$(INCLUDE)}"\ace\config-win32-common.h"\
+ {$(INCLUDE)}"\ace\config-win32.h"\
+ {$(INCLUDE)}"\ace\config.h"\
+ {$(INCLUDE)}"\ace\Connector.cpp"\
+ {$(INCLUDE)}"\ace\Connector.h"\
+ {$(INCLUDE)}"\ace\Connector.i"\
+ {$(INCLUDE)}"\ace\Containers.cpp"\
+ {$(INCLUDE)}"\ace\Containers.h"\
+ {$(INCLUDE)}"\ace\Containers.i"\
+ {$(INCLUDE)}"\ace\Dynamic.h"\
+ {$(INCLUDE)}"\ace\Dynamic.i"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.cpp"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.i"\
+ {$(INCLUDE)}"\ace\Free_List.cpp"\
+ {$(INCLUDE)}"\ace\Free_List.h"\
+ {$(INCLUDE)}"\ace\Free_List.i"\
+ {$(INCLUDE)}"\ace\Get_Opt.h"\
+ {$(INCLUDE)}"\ace\Get_Opt.i"\
+ {$(INCLUDE)}"\ace\Handle_Set.h"\
+ {$(INCLUDE)}"\ace\Handle_Set.i"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.i"\
+ {$(INCLUDE)}"\ace\IO_Cntl_Msg.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.i"\
+ {$(INCLUDE)}"\ace\Log_Msg.h"\
+ {$(INCLUDE)}"\ace\Log_Priority.h"\
+ {$(INCLUDE)}"\ace\Log_Record.h"\
+ {$(INCLUDE)}"\ace\Log_Record.i"\
+ {$(INCLUDE)}"\ace\Malloc.h"\
+ {$(INCLUDE)}"\ace\Malloc.i"\
+ {$(INCLUDE)}"\ace\Malloc_T.cpp"\
+ {$(INCLUDE)}"\ace\Malloc_T.h"\
+ {$(INCLUDE)}"\ace\Malloc_T.i"\
+ {$(INCLUDE)}"\ace\Managed_Object.cpp"\
+ {$(INCLUDE)}"\ace\Managed_Object.h"\
+ {$(INCLUDE)}"\ace\Managed_Object.i"\
+ {$(INCLUDE)}"\ace\Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Map_Manager.h"\
+ {$(INCLUDE)}"\ace\Map_Manager.i"\
+ {$(INCLUDE)}"\ace\Mem_Map.h"\
+ {$(INCLUDE)}"\ace\Mem_Map.i"\
+ {$(INCLUDE)}"\ace\Memory_Pool.h"\
+ {$(INCLUDE)}"\ace\Memory_Pool.i"\
+ {$(INCLUDE)}"\ace\Message_Block.h"\
+ {$(INCLUDE)}"\ace\Message_Block.i"\
+ {$(INCLUDE)}"\ace\Message_Queue.cpp"\
+ {$(INCLUDE)}"\ace\Message_Queue.h"\
+ {$(INCLUDE)}"\ace\Message_Queue.i"\
+ {$(INCLUDE)}"\ace\Module.cpp"\
+ {$(INCLUDE)}"\ace\Module.h"\
+ {$(INCLUDE)}"\ace\Module.i"\
+ {$(INCLUDE)}"\ace\Object_Manager.h"\
+ {$(INCLUDE)}"\ace\Object_Manager.i"\
+ {$(INCLUDE)}"\ace\OS.h"\
+ {$(INCLUDE)}"\ace\OS.i"\
+ {$(INCLUDE)}"\ace\Reactor.h"\
+ {$(INCLUDE)}"\ace\Reactor.i"\
+ {$(INCLUDE)}"\ace\Reactor_Impl.h"\
+ {$(INCLUDE)}"\ace\Service_Config.h"\
+ {$(INCLUDE)}"\ace\Service_Config.i"\
+ {$(INCLUDE)}"\ace\Service_Object.h"\
+ {$(INCLUDE)}"\ace\Service_Object.i"\
+ {$(INCLUDE)}"\ace\Service_Repository.h"\
+ {$(INCLUDE)}"\ace\Service_Repository.i"\
+ {$(INCLUDE)}"\ace\Service_Types.h"\
+ {$(INCLUDE)}"\ace\Service_Types.i"\
+ {$(INCLUDE)}"\ace\Shared_Object.h"\
+ {$(INCLUDE)}"\ace\Shared_Object.i"\
+ {$(INCLUDE)}"\ace\Signal.h"\
+ {$(INCLUDE)}"\ace\Signal.i"\
+ {$(INCLUDE)}"\ace\Singleton.cpp"\
+ {$(INCLUDE)}"\ace\Singleton.h"\
+ {$(INCLUDE)}"\ace\Singleton.i"\
+ {$(INCLUDE)}"\ace\SOCK.h"\
+ {$(INCLUDE)}"\ace\SOCK.i"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.h"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.i"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.h"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.i"\
+ {$(INCLUDE)}"\ace\SOCK_IO.h"\
+ {$(INCLUDE)}"\ace\SOCK_IO.i"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.h"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.i"\
+ {$(INCLUDE)}"\ace\SString.h"\
+ {$(INCLUDE)}"\ace\SString.i"\
+ {$(INCLUDE)}"\ace\stdcpp.h"\
+ {$(INCLUDE)}"\ace\Strategies.h"\
+ {$(INCLUDE)}"\ace\Strategies_T.cpp"\
+ {$(INCLUDE)}"\ace\Strategies_T.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.cpp"\
+ {$(INCLUDE)}"\ace\Stream_Modules.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.i"\
+ {$(INCLUDE)}"\ace\Svc_Conf_Tokens.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.cpp"\
+ {$(INCLUDE)}"\ace\Svc_Handler.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.i"\
+ {$(INCLUDE)}"\ace\Synch.h"\
+ {$(INCLUDE)}"\ace\Synch.i"\
+ {$(INCLUDE)}"\ace\Synch_Options.h"\
+ {$(INCLUDE)}"\ace\Synch_T.cpp"\
+ {$(INCLUDE)}"\ace\Synch_T.h"\
+ {$(INCLUDE)}"\ace\Synch_T.i"\
+ {$(INCLUDE)}"\ace\Task.h"\
+ {$(INCLUDE)}"\ace\Task.i"\
+ {$(INCLUDE)}"\ace\Task_T.cpp"\
+ {$(INCLUDE)}"\ace\Task_T.h"\
+ {$(INCLUDE)}"\ace\Task_T.i"\
+ {$(INCLUDE)}"\ace\Thread.h"\
+ {$(INCLUDE)}"\ace\Thread.i"\
+ {$(INCLUDE)}"\ace\Thread_Manager.h"\
+ {$(INCLUDE)}"\ace\Thread_Manager.i"\
+ {$(INCLUDE)}"\ace\Time_Value.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.cpp"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.i"\
+ {$(INCLUDE)}"\ace\Trace.h"\
+ {$(INCLUDE)}"\ace\Version.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.i"\
+ {$(INCLUDE)}"\ace\ws2tcpip.h"\
+ {$(INCLUDE)}"\tao\align.h"\
+ {$(INCLUDE)}"\tao\any.h"\
+ {$(INCLUDE)}"\tao\any.i"\
+ {$(INCLUDE)}"\tao\cdr.h"\
+ {$(INCLUDE)}"\tao\cdr.i"\
+ {$(INCLUDE)}"\tao\client_factory.h"\
+ {$(INCLUDE)}"\tao\client_factory.i"\
+ {$(INCLUDE)}"\tao\connect.h"\
+ {$(INCLUDE)}"\tao\connect.i"\
+ {$(INCLUDE)}"\tao\corba.h"\
+ {$(INCLUDE)}"\tao\corbacom.h"\
+ {$(INCLUDE)}"\tao\corbacom.i"\
+ {$(INCLUDE)}"\tao\debug.h"\
+ {$(INCLUDE)}"\tao\default_client.h"\
+ {$(INCLUDE)}"\tao\default_client.i"\
+ {$(INCLUDE)}"\tao\default_server.h"\
+ {$(INCLUDE)}"\tao\default_server.i"\
+ {$(INCLUDE)}"\tao\except.h"\
+ {$(INCLUDE)}"\tao\giop.h"\
+ {$(INCLUDE)}"\tao\giop.i"\
+ {$(INCLUDE)}"\tao\iiopobj.h"\
+ {$(INCLUDE)}"\tao\iiopobj.i"\
+ {$(INCLUDE)}"\tao\iioporb.h"\
+ {$(INCLUDE)}"\tao\iioporb.i"\
+ {$(INCLUDE)}"\tao\marshal.h"\
+ {$(INCLUDE)}"\tao\marshal.i"\
+ {$(INCLUDE)}"\tao\nvlist.h"\
+ {$(INCLUDE)}"\tao\object.h"\
+ {$(INCLUDE)}"\tao\object.i"\
+ {$(INCLUDE)}"\tao\objtable.h"\
+ {$(INCLUDE)}"\tao\optable.h"\
+ {$(INCLUDE)}"\tao\orb.h"\
+ {$(INCLUDE)}"\tao\orb_core.h"\
+ {$(INCLUDE)}"\tao\orb_core.i"\
+ {$(INCLUDE)}"\tao\orbconf.h"\
+ {$(INCLUDE)}"\tao\orbobj.h"\
+ {$(INCLUDE)}"\tao\orbobj.i"\
+ {$(INCLUDE)}"\tao\params.h"\
+ {$(INCLUDE)}"\tao\params.i"\
+ {$(INCLUDE)}"\tao\poa.h"\
+ {$(INCLUDE)}"\tao\poa.i"\
+ {$(INCLUDE)}"\tao\principa.h"\
+ {$(INCLUDE)}"\tao\request.h"\
+ {$(INCLUDE)}"\tao\sequence.h"\
+ {$(INCLUDE)}"\tao\sequence.i"\
+ {$(INCLUDE)}"\tao\server_factory.h"\
+ {$(INCLUDE)}"\tao\server_factory.i"\
+ {$(INCLUDE)}"\tao\singletons.h"\
+ {$(INCLUDE)}"\tao\stub.h"\
+ {$(INCLUDE)}"\tao\stub.i"\
+ {$(INCLUDE)}"\tao\svrrqst.h"\
+ {$(INCLUDE)}"\tao\svrrqst.i"\
+ {$(INCLUDE)}"\tao\typecode.h"\
+ {$(INCLUDE)}"\tao\typecode.i"\
+ {$(INCLUDE)}"\tao\varout.h"\
+
+NODEP_CPP_SVR_C=\
+ "..\..\..\..\tao\tao\factories.h"\
+
+
+"$(INTDIR)\svr.obj" : $(SOURCE) $(DEP_CPP_SVR_C) "$(INTDIR)" ".\cubitC.h"\
+ ".\cubitC.i" ".\cubitS.h" ".\cubitS.i"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cubitS.cpp
+DEP_CPP_CUBIT=\
+ ".\cubitC.h"\
+ ".\cubitC.i"\
+ ".\cubitS.h"\
+ ".\cubitS.i"\
+ {$(INCLUDE)}"\ace\Acceptor.cpp"\
+ {$(INCLUDE)}"\ace\Acceptor.h"\
+ {$(INCLUDE)}"\ace\Acceptor.i"\
+ {$(INCLUDE)}"\ace\ACE.h"\
+ {$(INCLUDE)}"\ace\ACE.i"\
+ {$(INCLUDE)}"\ace\Addr.h"\
+ {$(INCLUDE)}"\ace\Addr.i"\
+ {$(INCLUDE)}"\ace\Atomic_Op.i"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.cpp"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.h"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.i"\
+ {$(INCLUDE)}"\ace\config-win32-common.h"\
+ {$(INCLUDE)}"\ace\config-win32.h"\
+ {$(INCLUDE)}"\ace\config.h"\
+ {$(INCLUDE)}"\ace\Connector.cpp"\
+ {$(INCLUDE)}"\ace\Connector.h"\
+ {$(INCLUDE)}"\ace\Connector.i"\
+ {$(INCLUDE)}"\ace\Containers.cpp"\
+ {$(INCLUDE)}"\ace\Containers.h"\
+ {$(INCLUDE)}"\ace\Containers.i"\
+ {$(INCLUDE)}"\ace\Dynamic.h"\
+ {$(INCLUDE)}"\ace\Dynamic.i"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.cpp"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.i"\
+ {$(INCLUDE)}"\ace\Free_List.cpp"\
+ {$(INCLUDE)}"\ace\Free_List.h"\
+ {$(INCLUDE)}"\ace\Free_List.i"\
+ {$(INCLUDE)}"\ace\Get_Opt.h"\
+ {$(INCLUDE)}"\ace\Get_Opt.i"\
+ {$(INCLUDE)}"\ace\Handle_Set.h"\
+ {$(INCLUDE)}"\ace\Handle_Set.i"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.i"\
+ {$(INCLUDE)}"\ace\IO_Cntl_Msg.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.i"\
+ {$(INCLUDE)}"\ace\Log_Msg.h"\
+ {$(INCLUDE)}"\ace\Log_Priority.h"\
+ {$(INCLUDE)}"\ace\Log_Record.h"\
+ {$(INCLUDE)}"\ace\Log_Record.i"\
+ {$(INCLUDE)}"\ace\Malloc.h"\
+ {$(INCLUDE)}"\ace\Malloc.i"\
+ {$(INCLUDE)}"\ace\Malloc_T.cpp"\
+ {$(INCLUDE)}"\ace\Malloc_T.h"\
+ {$(INCLUDE)}"\ace\Malloc_T.i"\
+ {$(INCLUDE)}"\ace\Managed_Object.cpp"\
+ {$(INCLUDE)}"\ace\Managed_Object.h"\
+ {$(INCLUDE)}"\ace\Managed_Object.i"\
+ {$(INCLUDE)}"\ace\Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Map_Manager.h"\
+ {$(INCLUDE)}"\ace\Map_Manager.i"\
+ {$(INCLUDE)}"\ace\Mem_Map.h"\
+ {$(INCLUDE)}"\ace\Mem_Map.i"\
+ {$(INCLUDE)}"\ace\Memory_Pool.h"\
+ {$(INCLUDE)}"\ace\Memory_Pool.i"\
+ {$(INCLUDE)}"\ace\Message_Block.h"\
+ {$(INCLUDE)}"\ace\Message_Block.i"\
+ {$(INCLUDE)}"\ace\Message_Queue.cpp"\
+ {$(INCLUDE)}"\ace\Message_Queue.h"\
+ {$(INCLUDE)}"\ace\Message_Queue.i"\
+ {$(INCLUDE)}"\ace\Module.cpp"\
+ {$(INCLUDE)}"\ace\Module.h"\
+ {$(INCLUDE)}"\ace\Module.i"\
+ {$(INCLUDE)}"\ace\Object_Manager.h"\
+ {$(INCLUDE)}"\ace\Object_Manager.i"\
+ {$(INCLUDE)}"\ace\OS.h"\
+ {$(INCLUDE)}"\ace\OS.i"\
+ {$(INCLUDE)}"\ace\Reactor.h"\
+ {$(INCLUDE)}"\ace\Reactor.i"\
+ {$(INCLUDE)}"\ace\Reactor_Impl.h"\
+ {$(INCLUDE)}"\ace\Service_Config.h"\
+ {$(INCLUDE)}"\ace\Service_Config.i"\
+ {$(INCLUDE)}"\ace\Service_Object.h"\
+ {$(INCLUDE)}"\ace\Service_Object.i"\
+ {$(INCLUDE)}"\ace\Service_Repository.h"\
+ {$(INCLUDE)}"\ace\Service_Repository.i"\
+ {$(INCLUDE)}"\ace\Service_Types.h"\
+ {$(INCLUDE)}"\ace\Service_Types.i"\
+ {$(INCLUDE)}"\ace\Shared_Object.h"\
+ {$(INCLUDE)}"\ace\Shared_Object.i"\
+ {$(INCLUDE)}"\ace\Signal.h"\
+ {$(INCLUDE)}"\ace\Signal.i"\
+ {$(INCLUDE)}"\ace\Singleton.cpp"\
+ {$(INCLUDE)}"\ace\Singleton.h"\
+ {$(INCLUDE)}"\ace\Singleton.i"\
+ {$(INCLUDE)}"\ace\SOCK.h"\
+ {$(INCLUDE)}"\ace\SOCK.i"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.h"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.i"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.h"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.i"\
+ {$(INCLUDE)}"\ace\SOCK_IO.h"\
+ {$(INCLUDE)}"\ace\SOCK_IO.i"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.h"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.i"\
+ {$(INCLUDE)}"\ace\SString.h"\
+ {$(INCLUDE)}"\ace\SString.i"\
+ {$(INCLUDE)}"\ace\stdcpp.h"\
+ {$(INCLUDE)}"\ace\Strategies.h"\
+ {$(INCLUDE)}"\ace\Strategies_T.cpp"\
+ {$(INCLUDE)}"\ace\Strategies_T.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.cpp"\
+ {$(INCLUDE)}"\ace\Stream_Modules.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.i"\
+ {$(INCLUDE)}"\ace\Svc_Conf_Tokens.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.cpp"\
+ {$(INCLUDE)}"\ace\Svc_Handler.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.i"\
+ {$(INCLUDE)}"\ace\Synch.h"\
+ {$(INCLUDE)}"\ace\Synch.i"\
+ {$(INCLUDE)}"\ace\Synch_Options.h"\
+ {$(INCLUDE)}"\ace\Synch_T.cpp"\
+ {$(INCLUDE)}"\ace\Synch_T.h"\
+ {$(INCLUDE)}"\ace\Synch_T.i"\
+ {$(INCLUDE)}"\ace\Task.h"\
+ {$(INCLUDE)}"\ace\Task.i"\
+ {$(INCLUDE)}"\ace\Task_T.cpp"\
+ {$(INCLUDE)}"\ace\Task_T.h"\
+ {$(INCLUDE)}"\ace\Task_T.i"\
+ {$(INCLUDE)}"\ace\Thread.h"\
+ {$(INCLUDE)}"\ace\Thread.i"\
+ {$(INCLUDE)}"\ace\Thread_Manager.h"\
+ {$(INCLUDE)}"\ace\Thread_Manager.i"\
+ {$(INCLUDE)}"\ace\Time_Value.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.cpp"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.i"\
+ {$(INCLUDE)}"\ace\Trace.h"\
+ {$(INCLUDE)}"\ace\Version.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.i"\
+ {$(INCLUDE)}"\ace\ws2tcpip.h"\
+ {$(INCLUDE)}"\tao\align.h"\
+ {$(INCLUDE)}"\tao\any.h"\
+ {$(INCLUDE)}"\tao\any.i"\
+ {$(INCLUDE)}"\tao\cdr.h"\
+ {$(INCLUDE)}"\tao\cdr.i"\
+ {$(INCLUDE)}"\tao\client_factory.h"\
+ {$(INCLUDE)}"\tao\client_factory.i"\
+ {$(INCLUDE)}"\tao\connect.h"\
+ {$(INCLUDE)}"\tao\connect.i"\
+ {$(INCLUDE)}"\tao\corba.h"\
+ {$(INCLUDE)}"\tao\corbacom.h"\
+ {$(INCLUDE)}"\tao\corbacom.i"\
+ {$(INCLUDE)}"\tao\debug.h"\
+ {$(INCLUDE)}"\tao\default_client.h"\
+ {$(INCLUDE)}"\tao\default_client.i"\
+ {$(INCLUDE)}"\tao\default_server.h"\
+ {$(INCLUDE)}"\tao\default_server.i"\
+ {$(INCLUDE)}"\tao\except.h"\
+ {$(INCLUDE)}"\tao\giop.h"\
+ {$(INCLUDE)}"\tao\giop.i"\
+ {$(INCLUDE)}"\tao\iiopobj.h"\
+ {$(INCLUDE)}"\tao\iiopobj.i"\
+ {$(INCLUDE)}"\tao\iioporb.h"\
+ {$(INCLUDE)}"\tao\iioporb.i"\
+ {$(INCLUDE)}"\tao\marshal.h"\
+ {$(INCLUDE)}"\tao\marshal.i"\
+ {$(INCLUDE)}"\tao\nvlist.h"\
+ {$(INCLUDE)}"\tao\object.h"\
+ {$(INCLUDE)}"\tao\object.i"\
+ {$(INCLUDE)}"\tao\objtable.h"\
+ {$(INCLUDE)}"\tao\optable.h"\
+ {$(INCLUDE)}"\tao\orb.h"\
+ {$(INCLUDE)}"\tao\orb_core.h"\
+ {$(INCLUDE)}"\tao\orb_core.i"\
+ {$(INCLUDE)}"\tao\orbconf.h"\
+ {$(INCLUDE)}"\tao\orbobj.h"\
+ {$(INCLUDE)}"\tao\orbobj.i"\
+ {$(INCLUDE)}"\tao\params.h"\
+ {$(INCLUDE)}"\tao\params.i"\
+ {$(INCLUDE)}"\tao\poa.h"\
+ {$(INCLUDE)}"\tao\poa.i"\
+ {$(INCLUDE)}"\tao\principa.h"\
+ {$(INCLUDE)}"\tao\request.h"\
+ {$(INCLUDE)}"\tao\sequence.h"\
+ {$(INCLUDE)}"\tao\sequence.i"\
+ {$(INCLUDE)}"\tao\server_factory.h"\
+ {$(INCLUDE)}"\tao\server_factory.i"\
+ {$(INCLUDE)}"\tao\singletons.h"\
+ {$(INCLUDE)}"\tao\stub.h"\
+ {$(INCLUDE)}"\tao\stub.i"\
+ {$(INCLUDE)}"\tao\svrrqst.h"\
+ {$(INCLUDE)}"\tao\svrrqst.i"\
+ {$(INCLUDE)}"\tao\typecode.h"\
+ {$(INCLUDE)}"\tao\typecode.i"\
+ {$(INCLUDE)}"\tao\varout.h"\
+
+NODEP_CPP_CUBIT=\
+ "..\..\..\..\tao\tao\factories.h"\
+
+
+"$(INTDIR)\cubitS.obj" : $(SOURCE) $(DEP_CPP_CUBIT) "$(INTDIR)" ".\cubitC.h"\
+ ".\cubitC.i" ".\cubitS.h" ".\cubitS.i"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\Cubit_Client.cpp
+DEP_CPP_CUBIT_=\
+ ".\Cubit_Client.h"\
+ ".\cubitC.h"\
+ ".\cubitC.i"\
+ ".\cubitS.h"\
+ ".\cubitS.i"\
+ {$(INCLUDE)}"\ace\Acceptor.cpp"\
+ {$(INCLUDE)}"\ace\Acceptor.h"\
+ {$(INCLUDE)}"\ace\Acceptor.i"\
+ {$(INCLUDE)}"\ace\ACE.h"\
+ {$(INCLUDE)}"\ace\ACE.i"\
+ {$(INCLUDE)}"\ace\Addr.h"\
+ {$(INCLUDE)}"\ace\Addr.i"\
+ {$(INCLUDE)}"\ace\Atomic_Op.i"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.cpp"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.h"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.i"\
+ {$(INCLUDE)}"\ace\config-win32-common.h"\
+ {$(INCLUDE)}"\ace\config-win32.h"\
+ {$(INCLUDE)}"\ace\config.h"\
+ {$(INCLUDE)}"\ace\Connector.cpp"\
+ {$(INCLUDE)}"\ace\Connector.h"\
+ {$(INCLUDE)}"\ace\Connector.i"\
+ {$(INCLUDE)}"\ace\Containers.cpp"\
+ {$(INCLUDE)}"\ace\Containers.h"\
+ {$(INCLUDE)}"\ace\Containers.i"\
+ {$(INCLUDE)}"\ace\Dynamic.h"\
+ {$(INCLUDE)}"\ace\Dynamic.i"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.cpp"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.i"\
+ {$(INCLUDE)}"\ace\Free_List.cpp"\
+ {$(INCLUDE)}"\ace\Free_List.h"\
+ {$(INCLUDE)}"\ace\Free_List.i"\
+ {$(INCLUDE)}"\ace\Get_Opt.h"\
+ {$(INCLUDE)}"\ace\Get_Opt.i"\
+ {$(INCLUDE)}"\ace\Handle_Set.h"\
+ {$(INCLUDE)}"\ace\Handle_Set.i"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.i"\
+ {$(INCLUDE)}"\ace\IO_Cntl_Msg.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.i"\
+ {$(INCLUDE)}"\ace\Log_Msg.h"\
+ {$(INCLUDE)}"\ace\Log_Priority.h"\
+ {$(INCLUDE)}"\ace\Log_Record.h"\
+ {$(INCLUDE)}"\ace\Log_Record.i"\
+ {$(INCLUDE)}"\ace\Malloc.h"\
+ {$(INCLUDE)}"\ace\Malloc.i"\
+ {$(INCLUDE)}"\ace\Malloc_T.cpp"\
+ {$(INCLUDE)}"\ace\Malloc_T.h"\
+ {$(INCLUDE)}"\ace\Malloc_T.i"\
+ {$(INCLUDE)}"\ace\Managed_Object.cpp"\
+ {$(INCLUDE)}"\ace\Managed_Object.h"\
+ {$(INCLUDE)}"\ace\Managed_Object.i"\
+ {$(INCLUDE)}"\ace\Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Map_Manager.h"\
+ {$(INCLUDE)}"\ace\Map_Manager.i"\
+ {$(INCLUDE)}"\ace\Mem_Map.h"\
+ {$(INCLUDE)}"\ace\Mem_Map.i"\
+ {$(INCLUDE)}"\ace\Memory_Pool.h"\
+ {$(INCLUDE)}"\ace\Memory_Pool.i"\
+ {$(INCLUDE)}"\ace\Message_Block.h"\
+ {$(INCLUDE)}"\ace\Message_Block.i"\
+ {$(INCLUDE)}"\ace\Message_Queue.cpp"\
+ {$(INCLUDE)}"\ace\Message_Queue.h"\
+ {$(INCLUDE)}"\ace\Message_Queue.i"\
+ {$(INCLUDE)}"\ace\Module.cpp"\
+ {$(INCLUDE)}"\ace\Module.h"\
+ {$(INCLUDE)}"\ace\Module.i"\
+ {$(INCLUDE)}"\ace\Object_Manager.h"\
+ {$(INCLUDE)}"\ace\Object_Manager.i"\
+ {$(INCLUDE)}"\ace\OS.h"\
+ {$(INCLUDE)}"\ace\OS.i"\
+ {$(INCLUDE)}"\ace\Reactor.h"\
+ {$(INCLUDE)}"\ace\Reactor.i"\
+ {$(INCLUDE)}"\ace\Reactor_Impl.h"\
+ {$(INCLUDE)}"\ace\Service_Config.h"\
+ {$(INCLUDE)}"\ace\Service_Config.i"\
+ {$(INCLUDE)}"\ace\Service_Object.h"\
+ {$(INCLUDE)}"\ace\Service_Object.i"\
+ {$(INCLUDE)}"\ace\Service_Repository.h"\
+ {$(INCLUDE)}"\ace\Service_Repository.i"\
+ {$(INCLUDE)}"\ace\Service_Types.h"\
+ {$(INCLUDE)}"\ace\Service_Types.i"\
+ {$(INCLUDE)}"\ace\Shared_Object.h"\
+ {$(INCLUDE)}"\ace\Shared_Object.i"\
+ {$(INCLUDE)}"\ace\Signal.h"\
+ {$(INCLUDE)}"\ace\Signal.i"\
+ {$(INCLUDE)}"\ace\Singleton.cpp"\
+ {$(INCLUDE)}"\ace\Singleton.h"\
+ {$(INCLUDE)}"\ace\Singleton.i"\
+ {$(INCLUDE)}"\ace\SOCK.h"\
+ {$(INCLUDE)}"\ace\SOCK.i"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.h"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.i"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.h"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.i"\
+ {$(INCLUDE)}"\ace\SOCK_IO.h"\
+ {$(INCLUDE)}"\ace\SOCK_IO.i"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.h"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.i"\
+ {$(INCLUDE)}"\ace\SString.h"\
+ {$(INCLUDE)}"\ace\SString.i"\
+ {$(INCLUDE)}"\ace\stdcpp.h"\
+ {$(INCLUDE)}"\ace\Strategies.h"\
+ {$(INCLUDE)}"\ace\Strategies_T.cpp"\
+ {$(INCLUDE)}"\ace\Strategies_T.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.cpp"\
+ {$(INCLUDE)}"\ace\Stream_Modules.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.i"\
+ {$(INCLUDE)}"\ace\Svc_Conf_Tokens.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.cpp"\
+ {$(INCLUDE)}"\ace\Svc_Handler.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.i"\
+ {$(INCLUDE)}"\ace\Synch.h"\
+ {$(INCLUDE)}"\ace\Synch.i"\
+ {$(INCLUDE)}"\ace\Synch_Options.h"\
+ {$(INCLUDE)}"\ace\Synch_T.cpp"\
+ {$(INCLUDE)}"\ace\Synch_T.h"\
+ {$(INCLUDE)}"\ace\Synch_T.i"\
+ {$(INCLUDE)}"\ace\Task.h"\
+ {$(INCLUDE)}"\ace\Task.i"\
+ {$(INCLUDE)}"\ace\Task_T.cpp"\
+ {$(INCLUDE)}"\ace\Task_T.h"\
+ {$(INCLUDE)}"\ace\Task_T.i"\
+ {$(INCLUDE)}"\ace\Thread.h"\
+ {$(INCLUDE)}"\ace\Thread.i"\
+ {$(INCLUDE)}"\ace\Thread_Manager.h"\
+ {$(INCLUDE)}"\ace\Thread_Manager.i"\
+ {$(INCLUDE)}"\ace\Time_Value.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.cpp"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.i"\
+ {$(INCLUDE)}"\ace\Trace.h"\
+ {$(INCLUDE)}"\ace\Version.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.i"\
+ {$(INCLUDE)}"\ace\ws2tcpip.h"\
+ {$(INCLUDE)}"\tao\align.h"\
+ {$(INCLUDE)}"\tao\any.h"\
+ {$(INCLUDE)}"\tao\any.i"\
+ {$(INCLUDE)}"\tao\cdr.h"\
+ {$(INCLUDE)}"\tao\cdr.i"\
+ {$(INCLUDE)}"\tao\client_factory.h"\
+ {$(INCLUDE)}"\tao\client_factory.i"\
+ {$(INCLUDE)}"\tao\connect.h"\
+ {$(INCLUDE)}"\tao\connect.i"\
+ {$(INCLUDE)}"\tao\corba.h"\
+ {$(INCLUDE)}"\tao\corbacom.h"\
+ {$(INCLUDE)}"\tao\corbacom.i"\
+ {$(INCLUDE)}"\tao\debug.h"\
+ {$(INCLUDE)}"\tao\default_client.h"\
+ {$(INCLUDE)}"\tao\default_client.i"\
+ {$(INCLUDE)}"\tao\default_server.h"\
+ {$(INCLUDE)}"\tao\default_server.i"\
+ {$(INCLUDE)}"\tao\except.h"\
+ {$(INCLUDE)}"\tao\giop.h"\
+ {$(INCLUDE)}"\tao\giop.i"\
+ {$(INCLUDE)}"\tao\iiopobj.h"\
+ {$(INCLUDE)}"\tao\iiopobj.i"\
+ {$(INCLUDE)}"\tao\iioporb.h"\
+ {$(INCLUDE)}"\tao\iioporb.i"\
+ {$(INCLUDE)}"\tao\marshal.h"\
+ {$(INCLUDE)}"\tao\marshal.i"\
+ {$(INCLUDE)}"\tao\nvlist.h"\
+ {$(INCLUDE)}"\tao\object.h"\
+ {$(INCLUDE)}"\tao\object.i"\
+ {$(INCLUDE)}"\tao\objtable.h"\
+ {$(INCLUDE)}"\tao\optable.h"\
+ {$(INCLUDE)}"\tao\orb.h"\
+ {$(INCLUDE)}"\tao\orb_core.h"\
+ {$(INCLUDE)}"\tao\orb_core.i"\
+ {$(INCLUDE)}"\tao\orbconf.h"\
+ {$(INCLUDE)}"\tao\orbobj.h"\
+ {$(INCLUDE)}"\tao\orbobj.i"\
+ {$(INCLUDE)}"\tao\params.h"\
+ {$(INCLUDE)}"\tao\params.i"\
+ {$(INCLUDE)}"\tao\poa.h"\
+ {$(INCLUDE)}"\tao\poa.i"\
+ {$(INCLUDE)}"\tao\principa.h"\
+ {$(INCLUDE)}"\tao\request.h"\
+ {$(INCLUDE)}"\tao\sequence.h"\
+ {$(INCLUDE)}"\tao\sequence.i"\
+ {$(INCLUDE)}"\tao\server_factory.h"\
+ {$(INCLUDE)}"\tao\server_factory.i"\
+ {$(INCLUDE)}"\tao\singletons.h"\
+ {$(INCLUDE)}"\tao\stub.h"\
+ {$(INCLUDE)}"\tao\stub.i"\
+ {$(INCLUDE)}"\tao\svrrqst.h"\
+ {$(INCLUDE)}"\tao\svrrqst.i"\
+ {$(INCLUDE)}"\tao\typecode.h"\
+ {$(INCLUDE)}"\tao\typecode.i"\
+ {$(INCLUDE)}"\tao\varout.h"\
+
+NODEP_CPP_CUBIT_=\
+ "..\..\..\..\tao\tao\factories.h"\
+
+
+"$(INTDIR)\Cubit_Client.obj" : $(SOURCE) $(DEP_CPP_CUBIT_) "$(INTDIR)" ".\cubitC.h"\
+ ".\cubitC.i" ".\cubitS.h" ".\cubitS.i"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cubitC.cpp
+DEP_CPP_CUBITC=\
+ ".\cubitC.h"\
+ ".\cubitC.i"\
+ {$(INCLUDE)}"\ace\Acceptor.cpp"\
+ {$(INCLUDE)}"\ace\Acceptor.h"\
+ {$(INCLUDE)}"\ace\Acceptor.i"\
+ {$(INCLUDE)}"\ace\ACE.h"\
+ {$(INCLUDE)}"\ace\ACE.i"\
+ {$(INCLUDE)}"\ace\Addr.h"\
+ {$(INCLUDE)}"\ace\Addr.i"\
+ {$(INCLUDE)}"\ace\Atomic_Op.i"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.cpp"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.h"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.i"\
+ {$(INCLUDE)}"\ace\config-win32-common.h"\
+ {$(INCLUDE)}"\ace\config-win32.h"\
+ {$(INCLUDE)}"\ace\config.h"\
+ {$(INCLUDE)}"\ace\Connector.cpp"\
+ {$(INCLUDE)}"\ace\Connector.h"\
+ {$(INCLUDE)}"\ace\Connector.i"\
+ {$(INCLUDE)}"\ace\Containers.cpp"\
+ {$(INCLUDE)}"\ace\Containers.h"\
+ {$(INCLUDE)}"\ace\Containers.i"\
+ {$(INCLUDE)}"\ace\Dynamic.h"\
+ {$(INCLUDE)}"\ace\Dynamic.i"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.cpp"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.i"\
+ {$(INCLUDE)}"\ace\Free_List.cpp"\
+ {$(INCLUDE)}"\ace\Free_List.h"\
+ {$(INCLUDE)}"\ace\Free_List.i"\
+ {$(INCLUDE)}"\ace\Get_Opt.h"\
+ {$(INCLUDE)}"\ace\Get_Opt.i"\
+ {$(INCLUDE)}"\ace\Handle_Set.h"\
+ {$(INCLUDE)}"\ace\Handle_Set.i"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.i"\
+ {$(INCLUDE)}"\ace\IO_Cntl_Msg.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.i"\
+ {$(INCLUDE)}"\ace\Log_Msg.h"\
+ {$(INCLUDE)}"\ace\Log_Priority.h"\
+ {$(INCLUDE)}"\ace\Log_Record.h"\
+ {$(INCLUDE)}"\ace\Log_Record.i"\
+ {$(INCLUDE)}"\ace\Malloc.h"\
+ {$(INCLUDE)}"\ace\Malloc.i"\
+ {$(INCLUDE)}"\ace\Malloc_T.cpp"\
+ {$(INCLUDE)}"\ace\Malloc_T.h"\
+ {$(INCLUDE)}"\ace\Malloc_T.i"\
+ {$(INCLUDE)}"\ace\Managed_Object.cpp"\
+ {$(INCLUDE)}"\ace\Managed_Object.h"\
+ {$(INCLUDE)}"\ace\Managed_Object.i"\
+ {$(INCLUDE)}"\ace\Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Map_Manager.h"\
+ {$(INCLUDE)}"\ace\Map_Manager.i"\
+ {$(INCLUDE)}"\ace\Mem_Map.h"\
+ {$(INCLUDE)}"\ace\Mem_Map.i"\
+ {$(INCLUDE)}"\ace\Memory_Pool.h"\
+ {$(INCLUDE)}"\ace\Memory_Pool.i"\
+ {$(INCLUDE)}"\ace\Message_Block.h"\
+ {$(INCLUDE)}"\ace\Message_Block.i"\
+ {$(INCLUDE)}"\ace\Message_Queue.cpp"\
+ {$(INCLUDE)}"\ace\Message_Queue.h"\
+ {$(INCLUDE)}"\ace\Message_Queue.i"\
+ {$(INCLUDE)}"\ace\Module.cpp"\
+ {$(INCLUDE)}"\ace\Module.h"\
+ {$(INCLUDE)}"\ace\Module.i"\
+ {$(INCLUDE)}"\ace\Object_Manager.h"\
+ {$(INCLUDE)}"\ace\Object_Manager.i"\
+ {$(INCLUDE)}"\ace\OS.h"\
+ {$(INCLUDE)}"\ace\OS.i"\
+ {$(INCLUDE)}"\ace\Reactor.h"\
+ {$(INCLUDE)}"\ace\Reactor.i"\
+ {$(INCLUDE)}"\ace\Reactor_Impl.h"\
+ {$(INCLUDE)}"\ace\Service_Config.h"\
+ {$(INCLUDE)}"\ace\Service_Config.i"\
+ {$(INCLUDE)}"\ace\Service_Object.h"\
+ {$(INCLUDE)}"\ace\Service_Object.i"\
+ {$(INCLUDE)}"\ace\Service_Repository.h"\
+ {$(INCLUDE)}"\ace\Service_Repository.i"\
+ {$(INCLUDE)}"\ace\Service_Types.h"\
+ {$(INCLUDE)}"\ace\Service_Types.i"\
+ {$(INCLUDE)}"\ace\Shared_Object.h"\
+ {$(INCLUDE)}"\ace\Shared_Object.i"\
+ {$(INCLUDE)}"\ace\Signal.h"\
+ {$(INCLUDE)}"\ace\Signal.i"\
+ {$(INCLUDE)}"\ace\Singleton.cpp"\
+ {$(INCLUDE)}"\ace\Singleton.h"\
+ {$(INCLUDE)}"\ace\Singleton.i"\
+ {$(INCLUDE)}"\ace\SOCK.h"\
+ {$(INCLUDE)}"\ace\SOCK.i"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.h"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.i"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.h"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.i"\
+ {$(INCLUDE)}"\ace\SOCK_IO.h"\
+ {$(INCLUDE)}"\ace\SOCK_IO.i"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.h"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.i"\
+ {$(INCLUDE)}"\ace\SString.h"\
+ {$(INCLUDE)}"\ace\SString.i"\
+ {$(INCLUDE)}"\ace\stdcpp.h"\
+ {$(INCLUDE)}"\ace\Strategies.h"\
+ {$(INCLUDE)}"\ace\Strategies_T.cpp"\
+ {$(INCLUDE)}"\ace\Strategies_T.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.cpp"\
+ {$(INCLUDE)}"\ace\Stream_Modules.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.i"\
+ {$(INCLUDE)}"\ace\Svc_Conf_Tokens.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.cpp"\
+ {$(INCLUDE)}"\ace\Svc_Handler.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.i"\
+ {$(INCLUDE)}"\ace\Synch.h"\
+ {$(INCLUDE)}"\ace\Synch.i"\
+ {$(INCLUDE)}"\ace\Synch_Options.h"\
+ {$(INCLUDE)}"\ace\Synch_T.cpp"\
+ {$(INCLUDE)}"\ace\Synch_T.h"\
+ {$(INCLUDE)}"\ace\Synch_T.i"\
+ {$(INCLUDE)}"\ace\Task.h"\
+ {$(INCLUDE)}"\ace\Task.i"\
+ {$(INCLUDE)}"\ace\Task_T.cpp"\
+ {$(INCLUDE)}"\ace\Task_T.h"\
+ {$(INCLUDE)}"\ace\Task_T.i"\
+ {$(INCLUDE)}"\ace\Thread.h"\
+ {$(INCLUDE)}"\ace\Thread.i"\
+ {$(INCLUDE)}"\ace\Thread_Manager.h"\
+ {$(INCLUDE)}"\ace\Thread_Manager.i"\
+ {$(INCLUDE)}"\ace\Time_Value.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.cpp"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.i"\
+ {$(INCLUDE)}"\ace\Trace.h"\
+ {$(INCLUDE)}"\ace\Version.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.i"\
+ {$(INCLUDE)}"\ace\ws2tcpip.h"\
+ {$(INCLUDE)}"\tao\align.h"\
+ {$(INCLUDE)}"\tao\any.h"\
+ {$(INCLUDE)}"\tao\any.i"\
+ {$(INCLUDE)}"\tao\cdr.h"\
+ {$(INCLUDE)}"\tao\cdr.i"\
+ {$(INCLUDE)}"\tao\client_factory.h"\
+ {$(INCLUDE)}"\tao\client_factory.i"\
+ {$(INCLUDE)}"\tao\connect.h"\
+ {$(INCLUDE)}"\tao\connect.i"\
+ {$(INCLUDE)}"\tao\corba.h"\
+ {$(INCLUDE)}"\tao\corbacom.h"\
+ {$(INCLUDE)}"\tao\corbacom.i"\
+ {$(INCLUDE)}"\tao\debug.h"\
+ {$(INCLUDE)}"\tao\default_client.h"\
+ {$(INCLUDE)}"\tao\default_client.i"\
+ {$(INCLUDE)}"\tao\default_server.h"\
+ {$(INCLUDE)}"\tao\default_server.i"\
+ {$(INCLUDE)}"\tao\except.h"\
+ {$(INCLUDE)}"\tao\giop.h"\
+ {$(INCLUDE)}"\tao\giop.i"\
+ {$(INCLUDE)}"\tao\iiopobj.h"\
+ {$(INCLUDE)}"\tao\iiopobj.i"\
+ {$(INCLUDE)}"\tao\iioporb.h"\
+ {$(INCLUDE)}"\tao\iioporb.i"\
+ {$(INCLUDE)}"\tao\marshal.h"\
+ {$(INCLUDE)}"\tao\marshal.i"\
+ {$(INCLUDE)}"\tao\nvlist.h"\
+ {$(INCLUDE)}"\tao\object.h"\
+ {$(INCLUDE)}"\tao\object.i"\
+ {$(INCLUDE)}"\tao\objtable.h"\
+ {$(INCLUDE)}"\tao\optable.h"\
+ {$(INCLUDE)}"\tao\orb.h"\
+ {$(INCLUDE)}"\tao\orb_core.h"\
+ {$(INCLUDE)}"\tao\orb_core.i"\
+ {$(INCLUDE)}"\tao\orbconf.h"\
+ {$(INCLUDE)}"\tao\orbobj.h"\
+ {$(INCLUDE)}"\tao\orbobj.i"\
+ {$(INCLUDE)}"\tao\params.h"\
+ {$(INCLUDE)}"\tao\params.i"\
+ {$(INCLUDE)}"\tao\poa.h"\
+ {$(INCLUDE)}"\tao\poa.i"\
+ {$(INCLUDE)}"\tao\principa.h"\
+ {$(INCLUDE)}"\tao\request.h"\
+ {$(INCLUDE)}"\tao\sequence.h"\
+ {$(INCLUDE)}"\tao\sequence.i"\
+ {$(INCLUDE)}"\tao\server_factory.h"\
+ {$(INCLUDE)}"\tao\server_factory.i"\
+ {$(INCLUDE)}"\tao\singletons.h"\
+ {$(INCLUDE)}"\tao\stub.h"\
+ {$(INCLUDE)}"\tao\stub.i"\
+ {$(INCLUDE)}"\tao\svrrqst.h"\
+ {$(INCLUDE)}"\tao\svrrqst.i"\
+ {$(INCLUDE)}"\tao\typecode.h"\
+ {$(INCLUDE)}"\tao\typecode.i"\
+ {$(INCLUDE)}"\tao\varout.h"\
+
+NODEP_CPP_CUBITC=\
+ "..\..\..\..\tao\tao\factories.h"\
+
+
+"$(INTDIR)\cubitC.obj" : $(SOURCE) $(DEP_CPP_CUBITC) "$(INTDIR)" ".\cubitC.h"\
+ ".\cubitC.i"
+
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cubit.idl
+
+!IF "$(CFG)" == "server - Win32 Release"
+
+# PROP Exclude_From_Build 0
+# Begin Custom Build - Compiling IDL file(s):
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\tao_idl.exe $(InputName).idl \
+
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "server - Win32 Debug"
+
+# PROP Exclude_From_Build 0
+# Begin Custom Build - Compiling IDL file(s):
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\tao_idl.exe $(InputName).idl \
+
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Target
+################################################################################
+# Begin Target
+
+# Name "client - Win32 Release"
+# Name "client - Win32 Debug"
+
+!IF "$(CFG)" == "client - Win32 Release"
+
+!ELSEIF "$(CFG)" == "client - Win32 Debug"
+
+!ENDIF
+
+################################################################################
+# Begin Source File
+
+SOURCE=.\clnt.cpp
+
+!IF "$(CFG)" == "client - Win32 Release"
+
+DEP_CPP_CLNT_=\
+ ".\clnt.h"\
+ ".\cubitC.h"\
+ ".\cubitC.i"\
+ {$(INCLUDE)}"\ace\Acceptor.cpp"\
+ {$(INCLUDE)}"\ace\Acceptor.h"\
+ {$(INCLUDE)}"\ace\Acceptor.i"\
+ {$(INCLUDE)}"\ace\ACE.h"\
+ {$(INCLUDE)}"\ace\ACE.i"\
+ {$(INCLUDE)}"\ace\Addr.h"\
+ {$(INCLUDE)}"\ace\Addr.i"\
+ {$(INCLUDE)}"\ace\Atomic_Op.i"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.cpp"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.h"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.i"\
+ {$(INCLUDE)}"\ace\config-win32-common.h"\
+ {$(INCLUDE)}"\ace\config-win32.h"\
+ {$(INCLUDE)}"\ace\config.h"\
+ {$(INCLUDE)}"\ace\Connector.cpp"\
+ {$(INCLUDE)}"\ace\Connector.h"\
+ {$(INCLUDE)}"\ace\Connector.i"\
+ {$(INCLUDE)}"\ace\Containers.cpp"\
+ {$(INCLUDE)}"\ace\Containers.h"\
+ {$(INCLUDE)}"\ace\Containers.i"\
+ {$(INCLUDE)}"\ace\Dynamic.h"\
+ {$(INCLUDE)}"\ace\Dynamic.i"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.cpp"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.i"\
+ {$(INCLUDE)}"\ace\Free_List.cpp"\
+ {$(INCLUDE)}"\ace\Free_List.h"\
+ {$(INCLUDE)}"\ace\Free_List.i"\
+ {$(INCLUDE)}"\ace\Get_Opt.h"\
+ {$(INCLUDE)}"\ace\Get_Opt.i"\
+ {$(INCLUDE)}"\ace\Handle_Set.h"\
+ {$(INCLUDE)}"\ace\Handle_Set.i"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.h"\
+ {$(INCLUDE)}"\ace\High_Res_Timer.h"\
+ {$(INCLUDE)}"\ace\High_Res_Timer.i"\
+ {$(INCLUDE)}"\ace\INET_Addr.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.i"\
+ {$(INCLUDE)}"\ace\IO_Cntl_Msg.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.i"\
+ {$(INCLUDE)}"\ace\Log_Msg.h"\
+ {$(INCLUDE)}"\ace\Log_Priority.h"\
+ {$(INCLUDE)}"\ace\Log_Record.h"\
+ {$(INCLUDE)}"\ace\Log_Record.i"\
+ {$(INCLUDE)}"\ace\Malloc.h"\
+ {$(INCLUDE)}"\ace\Malloc.i"\
+ {$(INCLUDE)}"\ace\Malloc_T.cpp"\
+ {$(INCLUDE)}"\ace\Malloc_T.h"\
+ {$(INCLUDE)}"\ace\Malloc_T.i"\
+ {$(INCLUDE)}"\ace\Managed_Object.cpp"\
+ {$(INCLUDE)}"\ace\Managed_Object.h"\
+ {$(INCLUDE)}"\ace\Managed_Object.i"\
+ {$(INCLUDE)}"\ace\Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Map_Manager.h"\
+ {$(INCLUDE)}"\ace\Map_Manager.i"\
+ {$(INCLUDE)}"\ace\Mem_Map.h"\
+ {$(INCLUDE)}"\ace\Mem_Map.i"\
+ {$(INCLUDE)}"\ace\Memory_Pool.h"\
+ {$(INCLUDE)}"\ace\Memory_Pool.i"\
+ {$(INCLUDE)}"\ace\Message_Block.h"\
+ {$(INCLUDE)}"\ace\Message_Block.i"\
+ {$(INCLUDE)}"\ace\Message_Queue.cpp"\
+ {$(INCLUDE)}"\ace\Message_Queue.h"\
+ {$(INCLUDE)}"\ace\Message_Queue.i"\
+ {$(INCLUDE)}"\ace\Module.cpp"\
+ {$(INCLUDE)}"\ace\Module.h"\
+ {$(INCLUDE)}"\ace\Module.i"\
+ {$(INCLUDE)}"\ace\Object_Manager.h"\
+ {$(INCLUDE)}"\ace\Object_Manager.i"\
+ {$(INCLUDE)}"\ace\OS.h"\
+ {$(INCLUDE)}"\ace\OS.i"\
+ {$(INCLUDE)}"\ace\Profile_Timer.h"\
+ {$(INCLUDE)}"\ace\Profile_Timer.i"\
+ {$(INCLUDE)}"\ace\Reactor.h"\
+ {$(INCLUDE)}"\ace\Reactor.i"\
+ {$(INCLUDE)}"\ace\Reactor_Impl.h"\
+ {$(INCLUDE)}"\ace\Service_Config.h"\
+ {$(INCLUDE)}"\ace\Service_Config.i"\
+ {$(INCLUDE)}"\ace\Service_Object.h"\
+ {$(INCLUDE)}"\ace\Service_Object.i"\
+ {$(INCLUDE)}"\ace\Service_Repository.h"\
+ {$(INCLUDE)}"\ace\Service_Repository.i"\
+ {$(INCLUDE)}"\ace\Service_Types.h"\
+ {$(INCLUDE)}"\ace\Service_Types.i"\
+ {$(INCLUDE)}"\ace\Shared_Object.h"\
+ {$(INCLUDE)}"\ace\Shared_Object.i"\
+ {$(INCLUDE)}"\ace\Signal.h"\
+ {$(INCLUDE)}"\ace\Signal.i"\
+ {$(INCLUDE)}"\ace\Singleton.cpp"\
+ {$(INCLUDE)}"\ace\Singleton.h"\
+ {$(INCLUDE)}"\ace\Singleton.i"\
+ {$(INCLUDE)}"\ace\SOCK.h"\
+ {$(INCLUDE)}"\ace\SOCK.i"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.h"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.i"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.h"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.i"\
+ {$(INCLUDE)}"\ace\SOCK_IO.h"\
+ {$(INCLUDE)}"\ace\SOCK_IO.i"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.h"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.i"\
+ {$(INCLUDE)}"\ace\SString.h"\
+ {$(INCLUDE)}"\ace\SString.i"\
+ {$(INCLUDE)}"\ace\stdcpp.h"\
+ {$(INCLUDE)}"\ace\Strategies.h"\
+ {$(INCLUDE)}"\ace\Strategies_T.cpp"\
+ {$(INCLUDE)}"\ace\Strategies_T.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.cpp"\
+ {$(INCLUDE)}"\ace\Stream_Modules.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.i"\
+ {$(INCLUDE)}"\ace\Svc_Conf_Tokens.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.cpp"\
+ {$(INCLUDE)}"\ace\Svc_Handler.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.i"\
+ {$(INCLUDE)}"\ace\Synch.h"\
+ {$(INCLUDE)}"\ace\Synch.i"\
+ {$(INCLUDE)}"\ace\Synch_Options.h"\
+ {$(INCLUDE)}"\ace\Synch_T.cpp"\
+ {$(INCLUDE)}"\ace\Synch_T.h"\
+ {$(INCLUDE)}"\ace\Synch_T.i"\
+ {$(INCLUDE)}"\ace\Task.h"\
+ {$(INCLUDE)}"\ace\Task.i"\
+ {$(INCLUDE)}"\ace\Task_T.cpp"\
+ {$(INCLUDE)}"\ace\Task_T.h"\
+ {$(INCLUDE)}"\ace\Task_T.i"\
+ {$(INCLUDE)}"\ace\Thread.h"\
+ {$(INCLUDE)}"\ace\Thread.i"\
+ {$(INCLUDE)}"\ace\Thread_Manager.h"\
+ {$(INCLUDE)}"\ace\Thread_Manager.i"\
+ {$(INCLUDE)}"\ace\Time_Value.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.cpp"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.i"\
+ {$(INCLUDE)}"\ace\Trace.h"\
+ {$(INCLUDE)}"\ace\Version.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.i"\
+ {$(INCLUDE)}"\ace\ws2tcpip.h"\
+ {$(INCLUDE)}"\tao\align.h"\
+ {$(INCLUDE)}"\tao\any.h"\
+ {$(INCLUDE)}"\tao\any.i"\
+ {$(INCLUDE)}"\tao\cdr.h"\
+ {$(INCLUDE)}"\tao\cdr.i"\
+ {$(INCLUDE)}"\tao\client_factory.h"\
+ {$(INCLUDE)}"\tao\connect.h"\
+ {$(INCLUDE)}"\tao\connect.i"\
+ {$(INCLUDE)}"\tao\corba.h"\
+ {$(INCLUDE)}"\tao\corbacom.h"\
+ {$(INCLUDE)}"\tao\corbacom.i"\
+ {$(INCLUDE)}"\tao\debug.h"\
+ {$(INCLUDE)}"\tao\default_client.h"\
+ {$(INCLUDE)}"\tao\default_client.i"\
+ {$(INCLUDE)}"\tao\default_server.h"\
+ {$(INCLUDE)}"\tao\default_server.i"\
+ {$(INCLUDE)}"\tao\except.h"\
+ {$(INCLUDE)}"\tao\giop.h"\
+ {$(INCLUDE)}"\tao\giop.i"\
+ {$(INCLUDE)}"\tao\iiopobj.h"\
+ {$(INCLUDE)}"\tao\iiopobj.i"\
+ {$(INCLUDE)}"\tao\iioporb.h"\
+ {$(INCLUDE)}"\tao\iioporb.i"\
+ {$(INCLUDE)}"\tao\marshal.h"\
+ {$(INCLUDE)}"\tao\marshal.i"\
+ {$(INCLUDE)}"\tao\nvlist.h"\
+ {$(INCLUDE)}"\tao\object.h"\
+ {$(INCLUDE)}"\tao\object.i"\
+ {$(INCLUDE)}"\tao\objtable.h"\
+ {$(INCLUDE)}"\tao\optable.h"\
+ {$(INCLUDE)}"\tao\orb.h"\
+ {$(INCLUDE)}"\tao\orb_core.h"\
+ {$(INCLUDE)}"\tao\orb_core.i"\
+ {$(INCLUDE)}"\tao\orbconf.h"\
+ {$(INCLUDE)}"\tao\orbobj.h"\
+ {$(INCLUDE)}"\tao\orbobj.i"\
+ {$(INCLUDE)}"\tao\params.h"\
+ {$(INCLUDE)}"\tao\params.i"\
+ {$(INCLUDE)}"\tao\poa.h"\
+ {$(INCLUDE)}"\tao\poa.i"\
+ {$(INCLUDE)}"\tao\principa.h"\
+ {$(INCLUDE)}"\tao\request.h"\
+ {$(INCLUDE)}"\tao\sequence.h"\
+ {$(INCLUDE)}"\tao\sequence.i"\
+ {$(INCLUDE)}"\tao\server_factory.h"\
+ {$(INCLUDE)}"\tao\server_factory.i"\
+ {$(INCLUDE)}"\tao\singletons.h"\
+ {$(INCLUDE)}"\tao\stub.h"\
+ {$(INCLUDE)}"\tao\stub.i"\
+ {$(INCLUDE)}"\tao\svrrqst.h"\
+ {$(INCLUDE)}"\tao\typecode.h"\
+ {$(INCLUDE)}"\tao\typecode.i"\
+ {$(INCLUDE)}"\tao\varout.h"\
+
+
+"$(INTDIR)\clnt.obj" : $(SOURCE) $(DEP_CPP_CLNT_) "$(INTDIR)"
+
+
+!ELSEIF "$(CFG)" == "client - Win32 Debug"
+
+DEP_CPP_CLNT_=\
+ ".\clnt.h"\
+ {$(INCLUDE)}"\ace\Acceptor.cpp"\
+ {$(INCLUDE)}"\ace\Acceptor.h"\
+ {$(INCLUDE)}"\ace\Acceptor.i"\
+ {$(INCLUDE)}"\ace\ACE.h"\
+ {$(INCLUDE)}"\ace\ACE.i"\
+ {$(INCLUDE)}"\ace\Addr.h"\
+ {$(INCLUDE)}"\ace\Addr.i"\
+ {$(INCLUDE)}"\ace\Atomic_Op.i"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.cpp"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.h"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.i"\
+ {$(INCLUDE)}"\ace\config-win32-common.h"\
+ {$(INCLUDE)}"\ace\config-win32.h"\
+ {$(INCLUDE)}"\ace\config.h"\
+ {$(INCLUDE)}"\ace\Connector.cpp"\
+ {$(INCLUDE)}"\ace\Connector.h"\
+ {$(INCLUDE)}"\ace\Connector.i"\
+ {$(INCLUDE)}"\ace\Containers.cpp"\
+ {$(INCLUDE)}"\ace\Containers.h"\
+ {$(INCLUDE)}"\ace\Containers.i"\
+ {$(INCLUDE)}"\ace\Dynamic.h"\
+ {$(INCLUDE)}"\ace\Dynamic.i"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.cpp"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.i"\
+ {$(INCLUDE)}"\ace\Free_List.cpp"\
+ {$(INCLUDE)}"\ace\Free_List.h"\
+ {$(INCLUDE)}"\ace\Free_List.i"\
+ {$(INCLUDE)}"\ace\Get_Opt.h"\
+ {$(INCLUDE)}"\ace\Get_Opt.i"\
+ {$(INCLUDE)}"\ace\Handle_Set.h"\
+ {$(INCLUDE)}"\ace\Handle_Set.i"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.h"\
+ {$(INCLUDE)}"\ace\High_Res_Timer.h"\
+ {$(INCLUDE)}"\ace\High_Res_Timer.i"\
+ {$(INCLUDE)}"\ace\INET_Addr.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.i"\
+ {$(INCLUDE)}"\ace\IO_Cntl_Msg.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.i"\
+ {$(INCLUDE)}"\ace\Log_Msg.h"\
+ {$(INCLUDE)}"\ace\Log_Priority.h"\
+ {$(INCLUDE)}"\ace\Log_Record.h"\
+ {$(INCLUDE)}"\ace\Log_Record.i"\
+ {$(INCLUDE)}"\ace\Malloc.h"\
+ {$(INCLUDE)}"\ace\Malloc.i"\
+ {$(INCLUDE)}"\ace\Malloc_T.cpp"\
+ {$(INCLUDE)}"\ace\Malloc_T.h"\
+ {$(INCLUDE)}"\ace\Malloc_T.i"\
+ {$(INCLUDE)}"\ace\Managed_Object.cpp"\
+ {$(INCLUDE)}"\ace\Managed_Object.h"\
+ {$(INCLUDE)}"\ace\Managed_Object.i"\
+ {$(INCLUDE)}"\ace\Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Map_Manager.h"\
+ {$(INCLUDE)}"\ace\Map_Manager.i"\
+ {$(INCLUDE)}"\ace\Mem_Map.h"\
+ {$(INCLUDE)}"\ace\Mem_Map.i"\
+ {$(INCLUDE)}"\ace\Memory_Pool.h"\
+ {$(INCLUDE)}"\ace\Memory_Pool.i"\
+ {$(INCLUDE)}"\ace\Message_Block.h"\
+ {$(INCLUDE)}"\ace\Message_Block.i"\
+ {$(INCLUDE)}"\ace\Message_Queue.cpp"\
+ {$(INCLUDE)}"\ace\Message_Queue.h"\
+ {$(INCLUDE)}"\ace\Message_Queue.i"\
+ {$(INCLUDE)}"\ace\Module.cpp"\
+ {$(INCLUDE)}"\ace\Module.h"\
+ {$(INCLUDE)}"\ace\Module.i"\
+ {$(INCLUDE)}"\ace\Object_Manager.h"\
+ {$(INCLUDE)}"\ace\Object_Manager.i"\
+ {$(INCLUDE)}"\ace\OS.h"\
+ {$(INCLUDE)}"\ace\OS.i"\
+ {$(INCLUDE)}"\ace\Profile_Timer.h"\
+ {$(INCLUDE)}"\ace\Profile_Timer.i"\
+ {$(INCLUDE)}"\ace\Reactor.h"\
+ {$(INCLUDE)}"\ace\Reactor.i"\
+ {$(INCLUDE)}"\ace\Reactor_Impl.h"\
+ {$(INCLUDE)}"\ace\Service_Config.h"\
+ {$(INCLUDE)}"\ace\Service_Config.i"\
+ {$(INCLUDE)}"\ace\Service_Object.h"\
+ {$(INCLUDE)}"\ace\Service_Object.i"\
+ {$(INCLUDE)}"\ace\Service_Repository.h"\
+ {$(INCLUDE)}"\ace\Service_Repository.i"\
+ {$(INCLUDE)}"\ace\Service_Types.h"\
+ {$(INCLUDE)}"\ace\Service_Types.i"\
+ {$(INCLUDE)}"\ace\Shared_Object.h"\
+ {$(INCLUDE)}"\ace\Shared_Object.i"\
+ {$(INCLUDE)}"\ace\Signal.h"\
+ {$(INCLUDE)}"\ace\Signal.i"\
+ {$(INCLUDE)}"\ace\Singleton.cpp"\
+ {$(INCLUDE)}"\ace\Singleton.h"\
+ {$(INCLUDE)}"\ace\Singleton.i"\
+ {$(INCLUDE)}"\ace\SOCK.h"\
+ {$(INCLUDE)}"\ace\SOCK.i"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.h"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.i"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.h"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.i"\
+ {$(INCLUDE)}"\ace\SOCK_IO.h"\
+ {$(INCLUDE)}"\ace\SOCK_IO.i"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.h"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.i"\
+ {$(INCLUDE)}"\ace\SString.h"\
+ {$(INCLUDE)}"\ace\SString.i"\
+ {$(INCLUDE)}"\ace\stdcpp.h"\
+ {$(INCLUDE)}"\ace\Strategies.h"\
+ {$(INCLUDE)}"\ace\Strategies_T.cpp"\
+ {$(INCLUDE)}"\ace\Strategies_T.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.cpp"\
+ {$(INCLUDE)}"\ace\Stream_Modules.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.i"\
+ {$(INCLUDE)}"\ace\Svc_Conf_Tokens.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.cpp"\
+ {$(INCLUDE)}"\ace\Svc_Handler.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.i"\
+ {$(INCLUDE)}"\ace\Synch.h"\
+ {$(INCLUDE)}"\ace\Synch.i"\
+ {$(INCLUDE)}"\ace\Synch_Options.h"\
+ {$(INCLUDE)}"\ace\Synch_T.cpp"\
+ {$(INCLUDE)}"\ace\Synch_T.h"\
+ {$(INCLUDE)}"\ace\Synch_T.i"\
+ {$(INCLUDE)}"\ace\Task.h"\
+ {$(INCLUDE)}"\ace\Task.i"\
+ {$(INCLUDE)}"\ace\Task_T.cpp"\
+ {$(INCLUDE)}"\ace\Task_T.h"\
+ {$(INCLUDE)}"\ace\Task_T.i"\
+ {$(INCLUDE)}"\ace\Thread.h"\
+ {$(INCLUDE)}"\ace\Thread.i"\
+ {$(INCLUDE)}"\ace\Thread_Manager.h"\
+ {$(INCLUDE)}"\ace\Thread_Manager.i"\
+ {$(INCLUDE)}"\ace\Time_Value.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.cpp"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.i"\
+ {$(INCLUDE)}"\ace\Trace.h"\
+ {$(INCLUDE)}"\ace\Version.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.i"\
+ {$(INCLUDE)}"\ace\ws2tcpip.h"\
+ {$(INCLUDE)}"\tao\align.h"\
+ {$(INCLUDE)}"\tao\any.h"\
+ {$(INCLUDE)}"\tao\any.i"\
+ {$(INCLUDE)}"\tao\cdr.h"\
+ {$(INCLUDE)}"\tao\cdr.i"\
+ {$(INCLUDE)}"\tao\client_factory.h"\
+ {$(INCLUDE)}"\tao\connect.h"\
+ {$(INCLUDE)}"\tao\connect.i"\
+ {$(INCLUDE)}"\tao\corba.h"\
+ {$(INCLUDE)}"\tao\corbacom.h"\
+ {$(INCLUDE)}"\tao\corbacom.i"\
+ {$(INCLUDE)}"\tao\debug.h"\
+ {$(INCLUDE)}"\tao\default_client.h"\
+ {$(INCLUDE)}"\tao\default_client.i"\
+ {$(INCLUDE)}"\tao\default_server.h"\
+ {$(INCLUDE)}"\tao\default_server.i"\
+ {$(INCLUDE)}"\tao\except.h"\
+ {$(INCLUDE)}"\tao\giop.h"\
+ {$(INCLUDE)}"\tao\giop.i"\
+ {$(INCLUDE)}"\tao\iiopobj.h"\
+ {$(INCLUDE)}"\tao\iiopobj.i"\
+ {$(INCLUDE)}"\tao\iioporb.h"\
+ {$(INCLUDE)}"\tao\iioporb.i"\
+ {$(INCLUDE)}"\tao\marshal.h"\
+ {$(INCLUDE)}"\tao\marshal.i"\
+ {$(INCLUDE)}"\tao\nvlist.h"\
+ {$(INCLUDE)}"\tao\object.h"\
+ {$(INCLUDE)}"\tao\object.i"\
+ {$(INCLUDE)}"\tao\objtable.h"\
+ {$(INCLUDE)}"\tao\optable.h"\
+ {$(INCLUDE)}"\tao\orb.h"\
+ {$(INCLUDE)}"\tao\orb_core.h"\
+ {$(INCLUDE)}"\tao\orb_core.i"\
+ {$(INCLUDE)}"\tao\orbconf.h"\
+ {$(INCLUDE)}"\tao\orbobj.h"\
+ {$(INCLUDE)}"\tao\orbobj.i"\
+ {$(INCLUDE)}"\tao\params.h"\
+ {$(INCLUDE)}"\tao\params.i"\
+ {$(INCLUDE)}"\tao\poa.h"\
+ {$(INCLUDE)}"\tao\poa.i"\
+ {$(INCLUDE)}"\tao\principa.h"\
+ {$(INCLUDE)}"\tao\request.h"\
+ {$(INCLUDE)}"\tao\sequence.h"\
+ {$(INCLUDE)}"\tao\sequence.i"\
+ {$(INCLUDE)}"\tao\server_factory.h"\
+ {$(INCLUDE)}"\tao\server_factory.i"\
+ {$(INCLUDE)}"\tao\singletons.h"\
+ {$(INCLUDE)}"\tao\stub.h"\
+ {$(INCLUDE)}"\tao\stub.i"\
+ {$(INCLUDE)}"\tao\svrrqst.h"\
+ {$(INCLUDE)}"\tao\typecode.h"\
+ {$(INCLUDE)}"\tao\typecode.i"\
+ {$(INCLUDE)}"\tao\varout.h"\
+
+
+"$(INTDIR)\clnt.obj" : $(SOURCE) $(DEP_CPP_CLNT_) "$(INTDIR)"
+
+
+!ENDIF
+
+# End Source File
+################################################################################
+# Begin Source File
+
+SOURCE=.\cubitC.cpp
+
+!IF "$(CFG)" == "client - Win32 Release"
+
+DEP_CPP_CUBITC=\
+ ".\cubitC.h"\
+ ".\cubitC.i"\
+ {$(INCLUDE)}"\ace\Acceptor.cpp"\
+ {$(INCLUDE)}"\ace\Acceptor.h"\
+ {$(INCLUDE)}"\ace\Acceptor.i"\
+ {$(INCLUDE)}"\ace\ACE.h"\
+ {$(INCLUDE)}"\ace\ACE.i"\
+ {$(INCLUDE)}"\ace\Addr.h"\
+ {$(INCLUDE)}"\ace\Addr.i"\
+ {$(INCLUDE)}"\ace\Atomic_Op.i"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.cpp"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.h"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.i"\
+ {$(INCLUDE)}"\ace\config-win32-common.h"\
+ {$(INCLUDE)}"\ace\config-win32.h"\
+ {$(INCLUDE)}"\ace\config.h"\
+ {$(INCLUDE)}"\ace\Connector.cpp"\
+ {$(INCLUDE)}"\ace\Connector.h"\
+ {$(INCLUDE)}"\ace\Connector.i"\
+ {$(INCLUDE)}"\ace\Containers.cpp"\
+ {$(INCLUDE)}"\ace\Containers.h"\
+ {$(INCLUDE)}"\ace\Containers.i"\
+ {$(INCLUDE)}"\ace\Dynamic.h"\
+ {$(INCLUDE)}"\ace\Dynamic.i"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.cpp"\
+ {$(INCLUDE)}"\ace\Dynamic_Service.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.i"\
+ {$(INCLUDE)}"\ace\Free_List.cpp"\
+ {$(INCLUDE)}"\ace\Free_List.h"\
+ {$(INCLUDE)}"\ace\Free_List.i"\
+ {$(INCLUDE)}"\ace\Get_Opt.h"\
+ {$(INCLUDE)}"\ace\Get_Opt.i"\
+ {$(INCLUDE)}"\ace\Handle_Set.h"\
+ {$(INCLUDE)}"\ace\Handle_Set.i"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.i"\
+ {$(INCLUDE)}"\ace\IO_Cntl_Msg.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.i"\
+ {$(INCLUDE)}"\ace\Log_Msg.h"\
+ {$(INCLUDE)}"\ace\Log_Priority.h"\
+ {$(INCLUDE)}"\ace\Log_Record.h"\
+ {$(INCLUDE)}"\ace\Log_Record.i"\
+ {$(INCLUDE)}"\ace\Malloc.h"\
+ {$(INCLUDE)}"\ace\Malloc.i"\
+ {$(INCLUDE)}"\ace\Malloc_T.cpp"\
+ {$(INCLUDE)}"\ace\Malloc_T.h"\
+ {$(INCLUDE)}"\ace\Malloc_T.i"\
+ {$(INCLUDE)}"\ace\Managed_Object.cpp"\
+ {$(INCLUDE)}"\ace\Managed_Object.h"\
+ {$(INCLUDE)}"\ace\Managed_Object.i"\
+ {$(INCLUDE)}"\ace\Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Map_Manager.h"\
+ {$(INCLUDE)}"\ace\Map_Manager.i"\
+ {$(INCLUDE)}"\ace\Mem_Map.h"\
+ {$(INCLUDE)}"\ace\Mem_Map.i"\
+ {$(INCLUDE)}"\ace\Memory_Pool.h"\
+ {$(INCLUDE)}"\ace\Memory_Pool.i"\
+ {$(INCLUDE)}"\ace\Message_Block.h"\
+ {$(INCLUDE)}"\ace\Message_Block.i"\
+ {$(INCLUDE)}"\ace\Message_Queue.cpp"\
+ {$(INCLUDE)}"\ace\Message_Queue.h"\
+ {$(INCLUDE)}"\ace\Message_Queue.i"\
+ {$(INCLUDE)}"\ace\Module.cpp"\
+ {$(INCLUDE)}"\ace\Module.h"\
+ {$(INCLUDE)}"\ace\Module.i"\
+ {$(INCLUDE)}"\ace\Object_Manager.h"\
+ {$(INCLUDE)}"\ace\Object_Manager.i"\
+ {$(INCLUDE)}"\ace\OS.h"\
+ {$(INCLUDE)}"\ace\OS.i"\
+ {$(INCLUDE)}"\ace\Reactor.h"\
+ {$(INCLUDE)}"\ace\Reactor.i"\
+ {$(INCLUDE)}"\ace\Reactor_Impl.h"\
+ {$(INCLUDE)}"\ace\Service_Config.h"\
+ {$(INCLUDE)}"\ace\Service_Config.i"\
+ {$(INCLUDE)}"\ace\Service_Object.h"\
+ {$(INCLUDE)}"\ace\Service_Object.i"\
+ {$(INCLUDE)}"\ace\Service_Repository.h"\
+ {$(INCLUDE)}"\ace\Service_Repository.i"\
+ {$(INCLUDE)}"\ace\Service_Types.h"\
+ {$(INCLUDE)}"\ace\Service_Types.i"\
+ {$(INCLUDE)}"\ace\Shared_Object.h"\
+ {$(INCLUDE)}"\ace\Shared_Object.i"\
+ {$(INCLUDE)}"\ace\Signal.h"\
+ {$(INCLUDE)}"\ace\Signal.i"\
+ {$(INCLUDE)}"\ace\Singleton.cpp"\
+ {$(INCLUDE)}"\ace\Singleton.h"\
+ {$(INCLUDE)}"\ace\Singleton.i"\
+ {$(INCLUDE)}"\ace\SOCK.h"\
+ {$(INCLUDE)}"\ace\SOCK.i"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.h"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.i"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.h"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.i"\
+ {$(INCLUDE)}"\ace\SOCK_IO.h"\
+ {$(INCLUDE)}"\ace\SOCK_IO.i"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.h"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.i"\
+ {$(INCLUDE)}"\ace\SString.h"\
+ {$(INCLUDE)}"\ace\SString.i"\
+ {$(INCLUDE)}"\ace\stdcpp.h"\
+ {$(INCLUDE)}"\ace\Strategies.h"\
+ {$(INCLUDE)}"\ace\Strategies_T.cpp"\
+ {$(INCLUDE)}"\ace\Strategies_T.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.cpp"\
+ {$(INCLUDE)}"\ace\Stream_Modules.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.i"\
+ {$(INCLUDE)}"\ace\Svc_Conf_Tokens.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.cpp"\
+ {$(INCLUDE)}"\ace\Svc_Handler.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.i"\
+ {$(INCLUDE)}"\ace\Synch.h"\
+ {$(INCLUDE)}"\ace\Synch.i"\
+ {$(INCLUDE)}"\ace\Synch_Options.h"\
+ {$(INCLUDE)}"\ace\Synch_T.cpp"\
+ {$(INCLUDE)}"\ace\Synch_T.h"\
+ {$(INCLUDE)}"\ace\Synch_T.i"\
+ {$(INCLUDE)}"\ace\Task.h"\
+ {$(INCLUDE)}"\ace\Task.i"\
+ {$(INCLUDE)}"\ace\Task_T.cpp"\
+ {$(INCLUDE)}"\ace\Task_T.h"\
+ {$(INCLUDE)}"\ace\Task_T.i"\
+ {$(INCLUDE)}"\ace\Thread.h"\
+ {$(INCLUDE)}"\ace\Thread.i"\
+ {$(INCLUDE)}"\ace\Thread_Manager.h"\
+ {$(INCLUDE)}"\ace\Thread_Manager.i"\
+ {$(INCLUDE)}"\ace\Time_Value.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.cpp"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.i"\
+ {$(INCLUDE)}"\ace\Trace.h"\
+ {$(INCLUDE)}"\ace\Version.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.i"\
+ {$(INCLUDE)}"\ace\ws2tcpip.h"\
+ {$(INCLUDE)}"\tao\align.h"\
+ {$(INCLUDE)}"\tao\any.h"\
+ {$(INCLUDE)}"\tao\any.i"\
+ {$(INCLUDE)}"\tao\cdr.h"\
+ {$(INCLUDE)}"\tao\cdr.i"\
+ {$(INCLUDE)}"\tao\client_factory.h"\
+ {$(INCLUDE)}"\tao\client_factory.i"\
+ {$(INCLUDE)}"\tao\connect.h"\
+ {$(INCLUDE)}"\tao\connect.i"\
+ {$(INCLUDE)}"\tao\corba.h"\
+ {$(INCLUDE)}"\tao\corbacom.h"\
+ {$(INCLUDE)}"\tao\corbacom.i"\
+ {$(INCLUDE)}"\tao\debug.h"\
+ {$(INCLUDE)}"\tao\default_client.h"\
+ {$(INCLUDE)}"\tao\default_client.i"\
+ {$(INCLUDE)}"\tao\default_server.h"\
+ {$(INCLUDE)}"\tao\default_server.i"\
+ {$(INCLUDE)}"\tao\except.h"\
+ {$(INCLUDE)}"\tao\giop.h"\
+ {$(INCLUDE)}"\tao\giop.i"\
+ {$(INCLUDE)}"\tao\iiopobj.h"\
+ {$(INCLUDE)}"\tao\iiopobj.i"\
+ {$(INCLUDE)}"\tao\iioporb.h"\
+ {$(INCLUDE)}"\tao\iioporb.i"\
+ {$(INCLUDE)}"\tao\marshal.h"\
+ {$(INCLUDE)}"\tao\marshal.i"\
+ {$(INCLUDE)}"\tao\nvlist.h"\
+ {$(INCLUDE)}"\tao\object.h"\
+ {$(INCLUDE)}"\tao\object.i"\
+ {$(INCLUDE)}"\tao\objtable.h"\
+ {$(INCLUDE)}"\tao\optable.h"\
+ {$(INCLUDE)}"\tao\orb.h"\
+ {$(INCLUDE)}"\tao\orb_core.h"\
+ {$(INCLUDE)}"\tao\orb_core.i"\
+ {$(INCLUDE)}"\tao\orbconf.h"\
+ {$(INCLUDE)}"\tao\orbobj.h"\
+ {$(INCLUDE)}"\tao\orbobj.i"\
+ {$(INCLUDE)}"\tao\params.h"\
+ {$(INCLUDE)}"\tao\params.i"\
+ {$(INCLUDE)}"\tao\poa.h"\
+ {$(INCLUDE)}"\tao\poa.i"\
+ {$(INCLUDE)}"\tao\principa.h"\
+ {$(INCLUDE)}"\tao\request.h"\
+ {$(INCLUDE)}"\tao\sequence.h"\
+ {$(INCLUDE)}"\tao\sequence.i"\
+ {$(INCLUDE)}"\tao\server_factory.h"\
+ {$(INCLUDE)}"\tao\server_factory.i"\
+ {$(INCLUDE)}"\tao\singletons.h"\
+ {$(INCLUDE)}"\tao\stub.h"\
+ {$(INCLUDE)}"\tao\stub.i"\
+ {$(INCLUDE)}"\tao\svrrqst.h"\
+ {$(INCLUDE)}"\tao\svrrqst.i"\
+ {$(INCLUDE)}"\tao\typecode.h"\
+ {$(INCLUDE)}"\tao\typecode.i"\
+ {$(INCLUDE)}"\tao\varout.h"\
+
+NODEP_CPP_CUBITC=\
+ "..\..\..\..\tao\tao\factories.h"\
+
+
+"$(INTDIR)\cubitC.obj" : $(SOURCE) $(DEP_CPP_CUBITC) "$(INTDIR)"
+
+
+!ELSEIF "$(CFG)" == "client - Win32 Debug"
+
+DEP_CPP_CUBITC=\
+ ".\cubitC.h"\
+ ".\cubitC.i"\
+ {$(INCLUDE)}"\ace\Acceptor.cpp"\
+ {$(INCLUDE)}"\ace\Acceptor.h"\
+ {$(INCLUDE)}"\ace\Acceptor.i"\
+ {$(INCLUDE)}"\ace\ACE.h"\
+ {$(INCLUDE)}"\ace\ACE.i"\
+ {$(INCLUDE)}"\ace\Addr.h"\
+ {$(INCLUDE)}"\ace\Addr.i"\
+ {$(INCLUDE)}"\ace\Atomic_Op.i"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.cpp"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.h"\
+ {$(INCLUDE)}"\ace\Auto_Ptr.i"\
+ {$(INCLUDE)}"\ace\config-win32-common.h"\
+ {$(INCLUDE)}"\ace\config-win32.h"\
+ {$(INCLUDE)}"\ace\config.h"\
+ {$(INCLUDE)}"\ace\Connector.cpp"\
+ {$(INCLUDE)}"\ace\Connector.h"\
+ {$(INCLUDE)}"\ace\Connector.i"\
+ {$(INCLUDE)}"\ace\Containers.cpp"\
+ {$(INCLUDE)}"\ace\Containers.h"\
+ {$(INCLUDE)}"\ace\Containers.i"\
+ {$(INCLUDE)}"\ace\Dynamic.h"\
+ {$(INCLUDE)}"\ace\Dynamic.i"\
+ {$(INCLUDE)}"\ace\Event_Handler.h"\
+ {$(INCLUDE)}"\ace\Event_Handler.i"\
+ {$(INCLUDE)}"\ace\Free_List.cpp"\
+ {$(INCLUDE)}"\ace\Free_List.h"\
+ {$(INCLUDE)}"\ace\Free_List.i"\
+ {$(INCLUDE)}"\ace\Get_Opt.h"\
+ {$(INCLUDE)}"\ace\Get_Opt.i"\
+ {$(INCLUDE)}"\ace\Handle_Set.h"\
+ {$(INCLUDE)}"\ace\Handle_Set.i"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Hash_Map_Manager.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.h"\
+ {$(INCLUDE)}"\ace\INET_Addr.i"\
+ {$(INCLUDE)}"\ace\IO_Cntl_Msg.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.h"\
+ {$(INCLUDE)}"\ace\IPC_SAP.i"\
+ {$(INCLUDE)}"\ace\Log_Msg.h"\
+ {$(INCLUDE)}"\ace\Log_Priority.h"\
+ {$(INCLUDE)}"\ace\Log_Record.h"\
+ {$(INCLUDE)}"\ace\Log_Record.i"\
+ {$(INCLUDE)}"\ace\Malloc.h"\
+ {$(INCLUDE)}"\ace\Malloc.i"\
+ {$(INCLUDE)}"\ace\Malloc_T.cpp"\
+ {$(INCLUDE)}"\ace\Malloc_T.h"\
+ {$(INCLUDE)}"\ace\Malloc_T.i"\
+ {$(INCLUDE)}"\ace\Managed_Object.cpp"\
+ {$(INCLUDE)}"\ace\Managed_Object.h"\
+ {$(INCLUDE)}"\ace\Managed_Object.i"\
+ {$(INCLUDE)}"\ace\Map_Manager.cpp"\
+ {$(INCLUDE)}"\ace\Map_Manager.h"\
+ {$(INCLUDE)}"\ace\Map_Manager.i"\
+ {$(INCLUDE)}"\ace\Mem_Map.h"\
+ {$(INCLUDE)}"\ace\Mem_Map.i"\
+ {$(INCLUDE)}"\ace\Memory_Pool.h"\
+ {$(INCLUDE)}"\ace\Memory_Pool.i"\
+ {$(INCLUDE)}"\ace\Message_Block.h"\
+ {$(INCLUDE)}"\ace\Message_Block.i"\
+ {$(INCLUDE)}"\ace\Message_Queue.cpp"\
+ {$(INCLUDE)}"\ace\Message_Queue.h"\
+ {$(INCLUDE)}"\ace\Message_Queue.i"\
+ {$(INCLUDE)}"\ace\Module.cpp"\
+ {$(INCLUDE)}"\ace\Module.h"\
+ {$(INCLUDE)}"\ace\Module.i"\
+ {$(INCLUDE)}"\ace\Object_Manager.h"\
+ {$(INCLUDE)}"\ace\Object_Manager.i"\
+ {$(INCLUDE)}"\ace\OS.h"\
+ {$(INCLUDE)}"\ace\OS.i"\
+ {$(INCLUDE)}"\ace\Reactor.h"\
+ {$(INCLUDE)}"\ace\Reactor.i"\
+ {$(INCLUDE)}"\ace\Reactor_Impl.h"\
+ {$(INCLUDE)}"\ace\Service_Config.h"\
+ {$(INCLUDE)}"\ace\Service_Config.i"\
+ {$(INCLUDE)}"\ace\Service_Object.h"\
+ {$(INCLUDE)}"\ace\Service_Object.i"\
+ {$(INCLUDE)}"\ace\Service_Types.h"\
+ {$(INCLUDE)}"\ace\Service_Types.i"\
+ {$(INCLUDE)}"\ace\Shared_Object.h"\
+ {$(INCLUDE)}"\ace\Shared_Object.i"\
+ {$(INCLUDE)}"\ace\Signal.h"\
+ {$(INCLUDE)}"\ace\Signal.i"\
+ {$(INCLUDE)}"\ace\Singleton.cpp"\
+ {$(INCLUDE)}"\ace\Singleton.h"\
+ {$(INCLUDE)}"\ace\Singleton.i"\
+ {$(INCLUDE)}"\ace\SOCK.h"\
+ {$(INCLUDE)}"\ace\SOCK.i"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.h"\
+ {$(INCLUDE)}"\ace\SOCK_Acceptor.i"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.h"\
+ {$(INCLUDE)}"\ace\SOCK_Connector.i"\
+ {$(INCLUDE)}"\ace\SOCK_IO.h"\
+ {$(INCLUDE)}"\ace\SOCK_IO.i"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.h"\
+ {$(INCLUDE)}"\ace\SOCK_Stream.i"\
+ {$(INCLUDE)}"\ace\SString.h"\
+ {$(INCLUDE)}"\ace\SString.i"\
+ {$(INCLUDE)}"\ace\stdcpp.h"\
+ {$(INCLUDE)}"\ace\Strategies.h"\
+ {$(INCLUDE)}"\ace\Strategies_T.cpp"\
+ {$(INCLUDE)}"\ace\Strategies_T.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.cpp"\
+ {$(INCLUDE)}"\ace\Stream_Modules.h"\
+ {$(INCLUDE)}"\ace\Stream_Modules.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Complex.i"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.h"\
+ {$(INCLUDE)}"\ace\SV_Semaphore_Simple.i"\
+ {$(INCLUDE)}"\ace\Svc_Conf_Tokens.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.cpp"\
+ {$(INCLUDE)}"\ace\Svc_Handler.h"\
+ {$(INCLUDE)}"\ace\Svc_Handler.i"\
+ {$(INCLUDE)}"\ace\Synch.h"\
+ {$(INCLUDE)}"\ace\Synch.i"\
+ {$(INCLUDE)}"\ace\Synch_Options.h"\
+ {$(INCLUDE)}"\ace\Synch_T.cpp"\
+ {$(INCLUDE)}"\ace\Synch_T.h"\
+ {$(INCLUDE)}"\ace\Synch_T.i"\
+ {$(INCLUDE)}"\ace\Task.h"\
+ {$(INCLUDE)}"\ace\Task.i"\
+ {$(INCLUDE)}"\ace\Task_T.cpp"\
+ {$(INCLUDE)}"\ace\Task_T.h"\
+ {$(INCLUDE)}"\ace\Task_T.i"\
+ {$(INCLUDE)}"\ace\Thread.h"\
+ {$(INCLUDE)}"\ace\Thread.i"\
+ {$(INCLUDE)}"\ace\Thread_Manager.h"\
+ {$(INCLUDE)}"\ace\Thread_Manager.i"\
+ {$(INCLUDE)}"\ace\Time_Value.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.cpp"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.h"\
+ {$(INCLUDE)}"\ace\Timer_Queue_T.i"\
+ {$(INCLUDE)}"\ace\Trace.h"\
+ {$(INCLUDE)}"\ace\Version.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.h"\
+ {$(INCLUDE)}"\ace\WFMO_Reactor.i"\
+ {$(INCLUDE)}"\ace\ws2tcpip.h"\
+ {$(INCLUDE)}"\tao\align.h"\
+ {$(INCLUDE)}"\tao\any.h"\
+ {$(INCLUDE)}"\tao\cdr.h"\
+ {$(INCLUDE)}"\tao\corba.h"\
+ {$(INCLUDE)}"\tao\corbacom.h"\
+ {$(INCLUDE)}"\tao\except.h"\
+ {$(INCLUDE)}"\tao\marshal.h"\
+ {$(INCLUDE)}"\tao\nvlist.h"\
+ {$(INCLUDE)}"\tao\object.h"\
+ {$(INCLUDE)}"\tao\orb.h"\
+ {$(INCLUDE)}"\tao\orbconf.h"\
+ {$(INCLUDE)}"\tao\principa.h"\
+ {$(INCLUDE)}"\tao\request.h"\
+ {$(INCLUDE)}"\tao\sequence.h"\
+ {$(INCLUDE)}"\tao\svrrqst.h"\
+ {$(INCLUDE)}"\tao\typecode.h"\
+ {$(INCLUDE)}"\tao\varout.h"\
+
+
+"$(INTDIR)\cubitC.obj" : $(SOURCE) $(DEP_CPP_CUBITC) "$(INTDIR)"
+
+
+!ENDIF
+
+# End Source File
+# End Target
+# End Project
+################################################################################
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit.mdp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit.mdp Binary files differnew file mode 100644 index 00000000000..69d6258a5c8 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit.mdp diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp new file mode 100644 index 00000000000..934eb5b5dbb --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.cpp @@ -0,0 +1,1138 @@ +// $Id$ + +#include "ace/Env_Value_T.h" +#include "ace/Read_Buffer.h" +#include "Cubit_Client.h" +#include "orbsvcs/CosNamingC.h" + +#include "tao/Timeprobe.h" +#include "RTI_IO.h" + +ACE_RCSID(IDL_Cubit, Cubit_Client, "$Id$") + +#if defined (ACE_ENABLE_TIMEPROBES) + + static const char *Cubit_Client_Timeprobe_Description[] = +{ + "Cubit_Client::cube_oneway - start", + "Cubit_Client::cube_oneway - end", + + "Cubit_Client::cube_void - start", + "Cubit_Client::cube_void - end", + + "Cubit_Client::cube_octet - start", + "Cubit_Client::cube_octet - end", + + "Cubit_Client::cube_short - start", + "Cubit_Client::cube_short - end", + + "Cubit_Client::cube_long - start", + "Cubit_Client::cube_long - end", + + "Cubit_Client::cube_struct - start", + "Cubit_Client::cube_struct - end", + + "Cubit_Client::cube_union - start", + "Cubit_Client::cube_union - end", + + "Cubit_Client::cube_long_sequence - start", + "Cubit_Client::cube_long_sequence - end", + + "Cubit_Client::cube_octet_sequence - start", + "Cubit_Client::cube_octet_sequence - end" + + "Cubit_Client::cube_rti_data - start", + "Cubit_Client::cube_rti_data - end" + +}; + +enum +{ + // Timeprobe description table start key + CUBIT_CLIENT_CUBE_ONEWAY_START = 10000, + CUBIT_CLIENT_CUBE_ONEWAY_END, + + CUBIT_CLIENT_CUBE_VOID_START, + CUBIT_CLIENT_CUBE_VOID_END, + + CUBIT_CLIENT_CUBE_OCTET_START, + CUBIT_CLIENT_CUBE_OCTET_END, + + CUBIT_CLIENT_CUBE_SHORT_START, + CUBIT_CLIENT_CUBE_SHORT_END, + + CUBIT_CLIENT_CUBE_LONG_START, + CUBIT_CLIENT_CUBE_LONG_END, + + CUBIT_CLIENT_CUBE_STRUCT_START, + CUBIT_CLIENT_CUBE_STRUCT_END, + + CUBIT_CLIENT_CUBE_UNION_START, + CUBIT_CLIENT_CUBE_UNION_END, + + CUBIT_CLIENT_CUBE_LONG_SEQUENCE_START, + CUBIT_CLIENT_CUBE_LONG_SEQUENCE_END, + + CUBIT_CLIENT_CUBE_OCTET_SEQUENCE_START, + CUBIT_CLIENT_CUBE_OCTET_SEQUENCE_END, + + CUBIT_CLIENT_CUBE_RTI_DATA_START, + CUBIT_CLIENT_CUBE_RTI_DATA_END, + +}; + +// Setup Timeprobes +ACE_TIMEPROBE_EVENT_DESCRIPTIONS (Cubit_Client_Timeprobe_Description, + CUBIT_CLIENT_CUBE_ONEWAY_START); + +#endif /* ACE_ENABLE_TIMEPROBES */ + +// Constructor. +Cubit_Client::Cubit_Client (void) + : cubit_factory_key_ (0), + loop_count_ (250), + shutdown_ (0), + cubit_ (Cubit::_nil ()), + call_count_ (0), + error_count_ (0), + cubit_factory_ior_file_ (0), + f_handle_ (ACE_INVALID_HANDLE), + use_naming_service_ (1), + only_void_ (0), + only_oneway_ (0) +{ +} + +// Simple function that returns the substraction of 117 from the +// parameter. + +int +Cubit_Client::func (u_int i) +{ + return i - 117; +} + +// Reads the Cubit factory ior from a file + +int +Cubit_Client::read_ior (char *filename) +{ + // Open the file for reading. + this->f_handle_ = ACE_OS::open (filename,0); + + if (this->f_handle_ == ACE_INVALID_HANDLE) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to open %s for writing: %p\n", + filename), + -1); + ACE_Read_Buffer ior_buffer (this->f_handle_); + char *data = ior_buffer.read (); + + if (data == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to allocate memory to read ior: %p\n"), + -1); + + this->cubit_factory_key_ = ACE_OS::strdup (data); + ior_buffer.alloc ()->free (data); + + return 0; +} + +// Parses the command line arguments and returns an error status. + +int +Cubit_Client::parse_args (void) +{ + ACE_Get_Opt get_opts (argc_, argv_, "ovdn:f:k:xs"); + int c; + int result; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'v': + this->only_void_ = 1; + break; + case 'o': + this->only_oneway_ = 1; + break; + case 'd': // debug flag + TAO_debug_level++; + break; + case 'n': // loop count + this->loop_count_ = + (u_int) ACE_OS::atoi (get_opts.optarg); + break; + case 'f': // read the IOR from the file. + result = this->read_ior (get_opts.optarg); + if (result < 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to read ior from %s : %p\n", + get_opts.optarg), + -1); + break; + case 'k': // read the cubit IOR from the command-line. + this->cubit_factory_key_ = + ACE_OS::strdup (get_opts.optarg); + break; + case 'x': + ACE_DEBUG ((LM_DEBUG, "We will shutdown the server\n")); + this->shutdown_ = 1; + break; + case 's': // Don't use the TAO Naming Service. + this->use_naming_service_ = 0; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-d]" + " [-n loopcount]" + " [-f cubit_factory-obj-ref-key-file]" + " [-k cubit-obj-ref-key]" + " [-x]" + " [-s]" + "\n", + this->argv_ [0]), + -1); + } + + // Indicates successful parsing of command line. + return 0; +} + +// Exercise the union. Cube a union. + +void +Cubit_Client::cube_union (void) +{ + CORBA::Environment env; + Cubit::oneof u; + + this->call_count_++; + + u.l (3); // use the long union branch. + + // Cube a "union" ... + Cubit::oneof r; + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START); + + r = this->cubit_->cube_union (u, this->env_); + } + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_union"); + this->error_count_++; + } + else + { + dmsg ("cube union ..."); + u.l (u.l () * u.l () * u.l ()) ; + + if (u.l () != r.l ()) + { + ACE_DEBUG ((LM_DEBUG, "** cube_union ERROR\n")); + this->error_count_++; + } + + } + + this->call_count_++; + + u._d (Cubit::e_3rd); +#if 0 + u.cm ().l = this->func (i); + u.cm ().s = this->func (i); + u.cm ().o = this->func (i); +#endif + + u.cm ().l = 7; + u.cm ().s = 5; + u.cm ().o = 3; + + // Cube another "union" which uses the default arm ... NOT tested yet + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_UNION_START); + + r = this->cubit_->cube_union (u, this->env_); + } + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_union"); + this->error_count_++; + } + else + { + dmsg ("cube union ..."); + u.cm ().l = u.cm ().l * u.cm ().l * u.cm ().l; + u.cm ().s = u.cm ().s * u.cm ().s * u.cm ().s; + u.cm ().o = u.cm ().o * u.cm ().o * u.cm ().o; + + if (u.cm ().l != r.cm ().l + || u.cm ().s != r.cm ().s + || u.cm ().o != r.cm ().o) + { + ACE_DEBUG ((LM_DEBUG, "** cube_union ERROR\n")); + this->error_count_++; + } + } +} + +// Cube a short. + +void +Cubit_Client::cube_short (int i) +{ + CORBA::Short arg_short = this->func (i); + + // Cube a short. + CORBA::Short ret_short; + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_SHORT_START); + + ret_short = cubit_->cube_short (arg_short, this->env_); + } + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_short"); + this->error_count_++; + } + else + { + dmsg2 ("cube short: %d --> %d\n", + arg_short, + ret_short); + arg_short = arg_short * arg_short * arg_short; + + if (arg_short != ret_short) + { + ACE_ERROR ((LM_ERROR, "** cube_short (%d) ERROR (--> %d)\n", + (CORBA::Short) this->func (i), + ret_short)); + this->error_count_++; + } + } +} + +// Oneway test. + +void +Cubit_Client::cube_oneway (int i) +{ + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ONEWAY_START); + + this->cubit_->cube_oneway (this->env_); + } + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_oneway"); + this->error_count_++; + } +} + +void +Cubit_Client::cube_void (int i) +{ + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_VOID_START); + + this->cubit_->cube_void (this->env_); + } + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_void"); + this->error_count_++; + } +} + +// Cube an octet + +void +Cubit_Client::cube_octet (int i) +{ + CORBA::Octet arg_octet = this->func (i); + + // Cube an octet. + CORBA::Octet ret_octet; + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_START); + + ret_octet = this->cubit_->cube_octet (arg_octet, this->env_); + } + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_octet"); + this->error_count_++; + } + else + { + dmsg2 ("cube octet: %d --> %d\n", arg_octet, ret_octet); + arg_octet = arg_octet * arg_octet * arg_octet; + if (arg_octet != ret_octet) { + ACE_DEBUG ((LM_DEBUG, + "** cube_octet (%d) ERROR (--> %d)\n", + (CORBA::Octet) this->func (i), + ret_octet)); + this->error_count_++; + } + } +} + +// calculate the cube from a long + +void +Cubit_Client::cube_long (int i) +{ + CORBA::Long arg_long = this->func (i); + + // Cube a long. + CORBA::Long ret_long; + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_START); + + ret_long = this->cubit_->cube_long (arg_long, this->env_); + } + + this->call_count_++; + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_long"); + this->error_count_++; + } + else + { + dmsg2 ("cube long: %d --> %d\n", arg_long, ret_long); + arg_long = arg_long * arg_long * arg_long; + + if (arg_long != ret_long) + { + ACE_ERROR ((LM_ERROR, + "** cube_long (%ld) ERROR (--> %ld)\n", + (CORBA::Long) this->func (i), + ret_long)); + this->error_count_++; + } + } +} + +// Cube the numbers in a struct + +void +Cubit_Client::cube_struct (int i) +{ + Cubit::Many arg_struct; + Cubit::Many ret_struct; + + this->call_count_++; + + arg_struct.l = this->func (i); + arg_struct.s = this->func (i); + arg_struct.o = this->func (i); + + // Cube a "struct" ... + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_STRUCT_START); + + ret_struct = this->cubit_->cube_struct (arg_struct, this->env_); + } + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_struct"); + this->error_count_++; + } + else + { + dmsg ("cube struct ..."); + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o) + { + ACE_ERROR ((LM_ERROR, "** cube_struct ERROR\n")); + this->error_count_++; + } + } +} + +// Cube the numbers in a sequence + +void +Cubit_Client::cube_long_sequence (int i, int l) +{ + this->call_count_++; + + Cubit::long_seq input (l); + input.length (l); + +#if 0 + // Fill in the input sequence... + for (int j = 0; j < l; ++j) + input[j] = j; +#else + // Just set the first item, otherwise it is hard to compare the + // results for longer sequences, i.e. more than just marshalling + // gets in the way. + input[0] = 4; +#endif + + Cubit::long_seq_var output; + Cubit::long_seq_out vout (output); + + // Cube the sequence + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_SEQUENCE_START); + + this->cubit_->cube_long_sequence (input, vout, this->env_); + } + + // Cubit::long_seq& output = *vout.ptr (); + // output = vout; + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_struct"); + this->error_count_++; + } + else + { + if (output->length () != input.length ()) + { + ACE_ERROR ((LM_ERROR, "** cube sequence, wrong length\n")); + this->error_count_++; + } + + u_int rl = output->length (); + if (input.length () < rl) + rl = input.length (); +#if 0 + for (u_int j = 0; j < rl; ++j) + { + CORBA::Long x = input[j]; + if (x*x*x != output[j]) + { + ACE_ERROR ((LM_ERROR, "** cube_long_sequence ERROR\n")); + this->error_count_++; + } + } +#else + CORBA::Long x = input[0]; + if (x * x *x != output[0]) + { + ACE_ERROR ((LM_ERROR, "** cube_long_sequence ERROR\n")); + this->error_count_++; + } +#endif + } +} + +void +Cubit_Client::cube_octet_sequence (int i, int l) +{ + this->call_count_++; + + Cubit::octet_seq input (l); + input.length (l); + +#if 0 + // Fill in the input sequence... + for (int j = 0; j < l; ++j) + input[j] = j; +#else + // Just set the first item, otherwise it is hard to compare the + // results for longer sequences, i.e. more than just marshalling + // gets in the way. + input[0] = 4; +#endif + + Cubit::octet_seq_var output; + Cubit::octet_seq_out vout (output); + + // Cube the sequence + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_SEQUENCE_START); + + this->cubit_->cube_octet_sequence (input, vout, this->env_); + } + + // Cubit::long_seq& output = *vout.ptr (); + // output = vout; + + if (this->env_.exception () != 0) + { + this->env_.print_exception ("from cube_struct"); + this->error_count_++; + } + else + { + if (output->length () != input.length ()) + { + ACE_ERROR ((LM_ERROR, "** cube octet, wrong length\n")); + this->error_count_++; + } + + u_int rl = output->length (); + if (input.length () < rl) + rl = input.length (); +#if 0 + for (u_int j = 0; j < rl; ++j) + { + CORBA::Octet x = input[j]; + if (x*x*x != output[j]) + { + ACE_ERROR ((LM_ERROR, "** cube_octet ERROR\n")); + this->error_count_++; + } + } +#else + CORBA::Octet x = input[0]; + if (x * x *x != output[0]) + { + ACE_ERROR ((LM_ERROR, "** cube_octet ERROR\n")); + this->error_count_++; + } +#endif + } +} + +void +Cubit_Client::cube_rti_data (int i, int numUpdates, int numAttrs) +{ + this->call_count_++; + + Cubit::RtiPacket input; + input.packetHeader.packetLength = 1; // this is probably redundant + input.packetHeader.federationHandle = 2; + input.packetHeader.channelHandle = 3; + input.packetHeader.packetColor = 4; + + input.msgs.length (numUpdates); + + for (int j = 0; j < numUpdates; ++j) + { + input.msgs[j].oumh (Cubit::RtiObjectUpdateMessageHeader ()); + Cubit::RtiObjectUpdateMessageHeader & oumh = input.msgs[j].oumh (); + oumh.updateLength = 2001; // redundant + oumh.updateTag = 2002; + oumh.objectHandle = 2003; + oumh.timestamp = 3.14159; + oumh.eventRetractionHandle = 2004; + oumh.classHandle = 2005; + oumh.sendingFederateHandle = 2006; + oumh.userTag = CORBA::string_dup ("beefcake!"); + oumh.regionData.length(0); + oumh.transportationHandle = 1; + oumh.orderingHandle = 1; + oumh.messagePayload.length (numAttrs); + + for (int k = 0; k < numAttrs; ++k) + { + oumh.messagePayload[k] = Cubit::HandleValuePair (); + Cubit::HandleValuePair &hvp = oumh.messagePayload[k]; + hvp.handle = k * k; + char *d1 = "somedata"; + hvp.data.length (ACE_OS::strlen (d1)+1); + ACE_OS::strcpy ((char *) hvp.data.get_buffer (), d1); + } + } + + Cubit::RtiPacket_var output; + Cubit::RtiPacket_out vout (output); + + // Cube the sequence + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, "Input: \n")); + print_RtiPacket (input); + } + + { + ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_RTI_DATA_START); + + this->cubit_->cube_rti_data (input, vout, this->env_); + } + if (TAO_debug_level > 0) + + { + ACE_DEBUG ((LM_DEBUG, "Output: \n")); + print_RtiPacket (*vout.ptr ()); + ACE_DEBUG ((LM_DEBUG,"need to check whether cubing happened\n")); + } +} + +void +Cubit_Client::print_stats (const char *call_name, + ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time) +{ + ACE_DEBUG ((LM_DEBUG, + "%s:\n", + call_name)); + + if (this->call_count_ > 0 && this->error_count_ == 0) + { +#if defined (ACE_LACKS_FLOATING_POINT) + // elapsed_time.real_time is in units of microseconds. + const u_int calls_per_sec = + this->call_count_ * 1000000u / elapsed_time.real_time; + + ACE_DEBUG ((LM_DEBUG, + "\treal_time\t= %u ms,\n" + "\t%u calls/second\n", + elapsed_time.real_time / 1000u, + calls_per_sec)); +#else /* ! ACE_LACKS_FLOATING_POINT */ + // elapsed_time.real_time is in units of seconds. + double calls_per_sec = this->call_count_ / elapsed_time.real_time; + + ACE_DEBUG ((LM_DEBUG, + "\treal_time\t= %0.06f ms, \n\t" + "user_time\t= %0.06f ms, \n\t" + "system_time\t= %0.06f ms\n" + "\t%0.00f calls/second\n", + elapsed_time.real_time < 0.0 ? 0.0 + : elapsed_time.real_time * ACE_ONE_SECOND_IN_MSECS, + elapsed_time.user_time < 0.0 ? 0.0 + : elapsed_time.user_time * ACE_ONE_SECOND_IN_MSECS, + elapsed_time.system_time < 0.0 ? 0.0 + : elapsed_time.system_time * ACE_ONE_SECOND_IN_MSECS, + calls_per_sec < 0.0 ? 0.0 : calls_per_sec)); +#endif /* ! ACE_LACKS_FLOATING_POINT */ + } + else + ACE_ERROR ((LM_ERROR, + "\tNo time stats printed. Call count zero or error ocurred.\n")); + + ACE_DEBUG ((LM_DEBUG, + "\t%d calls, %d errors\n", + this->call_count_, + this->error_count_)); +} + +// Execute client example code. + +int +Cubit_Client::run (int testing_collocation) +{ + if (this->only_void_) + return this->run_void (); + + if (this->only_oneway_) + return this->run_oneway (); + + u_int i; + + ACE_Profile_Timer timer; + ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time; + // ACE_Time_Value before; + + // Show the results one type at a time. + + // VOID + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_void (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_void", elapsed_time); + + // SHORT + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_short (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_short", elapsed_time); + + // OCTET + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_octet (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_octet", elapsed_time); + + // LONG + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_long (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_long", elapsed_time); + + // STRUCT + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_struct (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_struct", elapsed_time); + + // UNION + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_union (); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_union_stub call", elapsed_time); + + // SMALL LONG SEQUENCES + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_long_sequence (this->loop_count_, 4); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_small_sequence<long>", elapsed_time); + + // LARGE LONG SEQUENCES + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_long_sequence (this->loop_count_, 1024); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_large_sequence<long>", elapsed_time); + + // SMALL OCTET SEQUENCES + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_octet_sequence (this->loop_count_, 16); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_small_sequence<octet>", elapsed_time); + + // LARGE OCTET SEQUENCES + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_octet_sequence (this->loop_count_, 4096); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_large_sequence<octet>", elapsed_time); + + // MIXIN + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + { + this->cube_short (i); + this->cube_octet (i); + this->cube_long (i); + } + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube mixin (short/octet/long)", elapsed_time); + + // RTI + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_rti_data (this->loop_count_, 2, 5); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_rti_data", elapsed_time); + + // ONEWAY + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_oneway (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_oneway", elapsed_time); + + if (testing_collocation) + { + // @@ Nanbor, this code should be split into a separate method. + TAO_ORB_Core_instance ()->using_collocation (0); + // Make sure we call the following method "remotely" so + // the right ORB could be used. + + if (this->init_naming_service () == -1) + return -1; + + TAO_TRY + { + this->cubit_ = + this->factory_->make_cubit (TAO_TRY_ENV); + TAO_CHECK_ENV; + + this->cubit_->shutdown (TAO_TRY_ENV); + TAO_CHECK_ENV; + + ACE_DEBUG ((LM_DEBUG, "shutdown on shutdown object\n")); + dexc (this->env_, + "server, please ACE_OS::exit"); + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("Cubit::init"); + return -1; + } + TAO_ENDTRY; + + } + else if (this->shutdown_) + { + ACE_DEBUG ((LM_DEBUG, "shutdown on cubit object\n")); + this->cubit_->shutdown (this->env_); + dexc (this->env_, "server, please ACE_OS::exit"); + } + + + return this->error_count_ == 0 ? 0 : 1; +} + +int +Cubit_Client::run_oneway (void) +{ + u_int i; + + ACE_Profile_Timer timer; + ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time; + // ACE_Time_Value before; + + + // ONEWAY + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_oneway (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_oneway", elapsed_time); + + if (this->shutdown_) + { + ACE_DEBUG ((LM_DEBUG, "shutdown on cubit object\n")); + this->cubit_->shutdown (this->env_); + dexc (this->env_, "server, please ACE_OS::exit"); + } + + return this->error_count_ == 0 ? 0 : 1; +} + +int +Cubit_Client::run_void (void) +{ + u_int i; + + ACE_Profile_Timer timer; + ACE_Profile_Timer::ACE_Elapsed_Time elapsed_time; + // ACE_Time_Value before; + + // VOID + this->call_count_ = 0; + this->error_count_ = 0; + timer.start (); + for (i = 0; i < this->loop_count_; i++) + this->cube_void (i); + timer.stop (); + timer.elapsed_time (elapsed_time); + this->print_stats ("cube_void", elapsed_time); + + if (this->shutdown_) + { + ACE_DEBUG ((LM_DEBUG, "shutdown on cubit object\n")); + this->cubit_->shutdown (this->env_); + dexc (this->env_, "server, please ACE_OS::exit"); + } + + return this->error_count_ == 0 ? 0 : 1; +} + +Cubit_Client::~Cubit_Client (void) +{ + // Free resources and close the IOR files. + if (this->cubit_factory_ior_file_) + ACE_OS::fclose (this->cubit_factory_ior_file_); + + if (this->f_handle_ != ACE_INVALID_HANDLE) + ACE_OS::close (this->f_handle_); + + if (this->cubit_factory_key_ != 0) + ACE_OS::free (this->cubit_factory_key_); +} + +int +Cubit_Client::init_naming_service (void) +{ + TAO_TRY + { + /* + // @@ This code should use the new TAO_Naming_Client helper + // class. + CORBA::Object_var naming_obj = + this->orb_->resolve_initial_references ("NameService"); + + if (CORBA::is_nil (naming_obj.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to resolve the NameService.\n"), + -1); + + CosNaming::NamingContext_var naming_context = + CosNaming::NamingContext::_narrow (naming_obj.in (), + TAO_TRY_ENV); + TAO_CHECK_ENV; + + */ + + // Initialize the naming services + if (my_name_client_.init (orb_.in (), argc_, argv_) != 0) + ACE_ERROR_RETURN ((LM_ERROR, + " (%P|%t) Unable to initialize " + "the TAO_Naming_Client. \n"), + -1); + + CosNaming::Name cubit_factory_name (2); + cubit_factory_name.length (2); + cubit_factory_name[0].id = + CORBA::string_dup ("IDL_Cubit"); + cubit_factory_name[1].id = + CORBA::string_dup ("cubit_factory"); + CORBA::Object_var factory_obj = + my_name_client_->resolve (cubit_factory_name, + TAO_TRY_ENV); + TAO_CHECK_ENV; + + this->factory_ = + Cubit_Factory::_narrow (factory_obj.in (), + TAO_TRY_ENV); + TAO_CHECK_ENV; + + if (CORBA::is_nil (this->factory_.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + " could not resolve cubit factory in Naming service <%s>\n"), + -1); + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("Cubit::init_naming_service"); + return -1; + } + TAO_ENDTRY; + + return 0; +} + +int +Cubit_Client::init (int argc, char **argv) +{ + this->argc_ = argc; + this->argv_ = argv; + + TAO_TRY + { + // Retrieve the ORB. + this->orb_ = CORBA::ORB_init (this->argc_, + this->argv_, + "internet", + TAO_TRY_ENV); + TAO_CHECK_ENV; + + // Parse command line and verify parameters. + if (this->parse_args () == -1) + return -1; + + if (this->use_naming_service_) + { + if (this->init_naming_service () == -1) + return -1; + } + else + { + if (this->cubit_factory_key_ == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "%s: no cubit factory key specified\n", + this->argv_[0]), + -1); + + CORBA::Object_var factory_object = + this->orb_->string_to_object (this->cubit_factory_key_, + TAO_TRY_ENV); + TAO_CHECK_ENV; + + this->factory_ = + Cubit_Factory::_narrow (factory_object.in(), + TAO_TRY_ENV); + TAO_CHECK_ENV; + + if (CORBA::is_nil (this->factory_.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + "invalid factory key <%s>\n", + this->cubit_factory_key_), + -1); + } + + ACE_DEBUG ((LM_DEBUG, + "Factory received OK\n")); + + // Now retrieve the Cubit obj ref corresponding to the key. + this->cubit_ = + this->factory_->make_cubit (TAO_TRY_ENV); + TAO_CHECK_ENV; + + if (CORBA::is_nil (this->cubit_.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + "null cubit objref returned by factory\n"), + -1); + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("Cubit::init"); + return -1; + } + TAO_ENDTRY; + + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) +template class ACE_Env_Value<unsigned long>; +template class ACE_Env_Value<unsigned short>; +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +#pragma instantiate ACE_Env_Value<unsigned long> +#pragma instantiate ACE_Env_Value<unsigned short> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h new file mode 100644 index 00000000000..ecb500169e7 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Client.h @@ -0,0 +1,160 @@ +// -*- c++ -*- +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// Cubit_Client.h +// +// = DESCRIPTION +// This class implements a simple "cube" CORBA client for the Cubit +// example using stubs generated by the TAO ORB IDL compiler. +// +// = AUTHORS +// Aniruddha Gokhale, Sumedh Mungee, and Sergio Flores-Gaitan +// +// ============================================================================ + +#if !defined (_CUBIT_CLIENT_H) +#define _CUBIT_CLIENT_H + +#include "ace/Get_Opt.h" +#include "ace/Profile_Timer.h" +#include "tao/corba.h" +#include "cubitC.h" +#include "orbsvcs/Naming/Naming_Utils.h" + +class Cubit_Client +{ + // = TITLE + // Defines a class that encapsulates behaviour of the Cubit client + // example. Provides a better understanding of the logic in an + // object oriented way. + // + // = DESCRIPTION + // This class declares an interface to run the example client for + // Cubit CORBA server. All the complexity for initializing the + // server is hidden in the class. Just the run() interface is needed. +public: + // = Constructor and destructor. + Cubit_Client (void); + ~Cubit_Client (void); + + int run (int testing_collocation = 0); + // Execute client example code. + + int init (int argc, char **argv); + // Initialize the client communication endpoint with server. + +private: + int init_naming_service (void); + // Function to initialize the naming service. + + int func (u_int i); + // Simple function that returns the substraction of 117 from the + // parameter. + + int read_ior (char *filename); + // Function to read the cubit factory ior from a file. + + int parse_args (void); + // Parses the arguments passed on the command line. + + void print_stats (const char *call_name, + ACE_Profile_Timer::ACE_Elapsed_Time &elapsed_time); + // Prints the time stats. + + void cube_union (void); + // Exercise the union. Cube a union. + + void cube_struct (int i); + // calculate the cube from a struct. + + void cube_long (int i); + // calculate the cube from a long. + + void cube_oneway (int i); + // Oneway operation test. + + void cube_void (int i); + // Twoway operation test. + + void cube_octet (int i); + // Cube an octet. + + void cube_short (int i); + // Cube a short. + + void cube_long_sequence (int i, int l); + // Cube a sequence <l> is the length of the sequence. + + void cube_octet_sequence (int i, int l); + // Cube a sequence of octets, <l> is the length of the sequence. + + void cube_rti_data (int i, int numUpdates, int numAttrs); + // Cube a sequence <l> is the length of the sequence. + + int run_void (void); + // This method runs only the cube_void() test. + + int run_oneway (void); + // This method runs only the cube_oneway() test. + + int argc_; + // # of arguments on the command line. + + char **argv_; + // arguments from command line. + + char *cubit_factory_key_; + // Key of factory obj ref. + + u_int loop_count_; + // Number of times to do the cube operations. + + int shutdown_; + // Flag to tell server to shutdown. + + Cubit_Factory_var factory_; + // factory pointer for cubit. + + CORBA::Environment env_; + // Environment variable. + + Cubit_var cubit_; + // Cubit obj ref. + + CORBA::ORB_var orb_; + // Remember our orb. + + u_int call_count_; + // # of calls made to functions. + + u_int error_count_; + // # of errors incurred in the lifetime of the application. + + FILE *cubit_factory_ior_file_; + // File from which to obtain the IOR. + + ACE_HANDLE f_handle_; + // File handle to read the IOR. + + int use_naming_service_; + // Flag to tell client not to use Namingservice to find the cubit + // Factory. + + int only_void_; + // Run only the cube_void() test. + + int only_oneway_; + // Run only the cube_oneway() test. + + TAO_Naming_Client my_name_client_; + // An instance of the name client used for resolving the factory + // objects. +}; + +#endif /* _CUBIT_CLIENT_H */ diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp new file mode 100644 index 00000000000..c2ca7d883d7 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.cpp @@ -0,0 +1,156 @@ +// $Id$ + +#include "Cubit_Server.h" + +ACE_RCSID(IDL_Cubit, Cubit_Server, "$Id$") + +Cubit_Server::Cubit_Server (void) + : use_naming_service_ (1), + ior_output_file_ (0) +{ +} + +int +Cubit_Server::parse_args (void) +{ + ACE_Get_Opt get_opts (argc_, argv_, "do:s"); + int c; + + while ((c = get_opts ()) != -1) + switch (c) + { + case 'd': // debug flag. + TAO_debug_level++; + break; + case 'o': // output the IOR to a file. + this->ior_output_file_ = ACE_OS::fopen (get_opts.optarg, "w"); + if (this->ior_output_file_ == 0) + ACE_ERROR_RETURN ((LM_ERROR, + "Unable to open %s for writing: %p\n", + get_opts.optarg), -1); + break; + case 's': // Don't use the TAO Naming Service. + this->use_naming_service_=0; + break; + case '?': + default: + ACE_ERROR_RETURN ((LM_ERROR, + "usage: %s" + " [-d]" + " [-n] <num of cubit objects>" + " [-o] <ior_output_file>" + " [-s]" + "\n", + argv_ [0]), + 1); + } + + // Indicates successful parsing of command line. + return 0; +} + +int +Cubit_Server::init (int argc, + char** argv, + CORBA::Environment& env) +{ + // 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", + env) == -1) + ACE_ERROR_RETURN ((LM_ERROR, + "%p\n", + "init_child_poa"), + -1); + TAO_CHECK_ENV_RETURN (env,-1); + this->argc_ = argc; + this->argv_ = argv; + + this->parse_args (); + // @@ Check for the return value here. + + // Get the orb + CORBA::ORB_var orb = this->orb_manager_.orb (); + + // Now create the implementations + this->factory_impl_ = new Cubit_Factory_i (orb.in ()); + + CORBA::String_var str = + this->orb_manager_.activate_under_child_poa ("factory", + this->factory_impl_, + env); + ACE_DEBUG ((LM_DEBUG, + "The IOR is: <%s>\n", + str.in ())); + + if (this->ior_output_file_) + { + ACE_OS::fprintf (this->ior_output_file_, + "%s", + str.in ()); + ACE_OS::fclose (this->ior_output_file_); + } + + if (this->use_naming_service_) + return this->init_naming_service (env); + + return 0; +} + +// Initialisation of Naming Service and register IDL_Cubit Context and +// cubit_factory object. + +int +Cubit_Server::init_naming_service (CORBA::Environment& env) +{ + int result; + CORBA::ORB_var orb; + PortableServer::POA_var child_poa; + + orb = this->orb_manager_.orb (); + child_poa = this->orb_manager_.child_poa (); + + result = this->my_name_server_.init (orb.in (), + child_poa.in ()); + if (result < 0) + return result; + Cubit_Factory_var factory = this->factory_impl_->_this (env); + TAO_CHECK_ENV_RETURN (env,-1); + + CosNaming::Name cubit_context_name (1); + cubit_context_name.length (1); + cubit_context_name[0].id = CORBA::string_dup ("IDL_Cubit"); + this->cubit_context_ = + this->my_name_server_->bind_new_context (cubit_context_name, + env); + TAO_CHECK_ENV_RETURN (env,-1); + + //Register the cubit_factory name with the IDL_Cubit Naming + //Context... + CosNaming::Name factory_name (1); + factory_name.length (1); + factory_name[0].id = CORBA::string_dup ("cubit_factory"); + this->cubit_context_->bind (factory_name, + factory.in (), + env); + TAO_CHECK_ENV_RETURN (env,-1); + + return 0; +} + +int +Cubit_Server::run (CORBA::Environment& env) +{ + if (this->orb_manager_.run (env) == -1) + ACE_ERROR_RETURN ((LM_ERROR, + "Cubit_Server::run"), + -1); + return 0; +} + +Cubit_Server::~Cubit_Server (void) +{ + delete this->factory_impl_; +} diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h new file mode 100644 index 00000000000..8a22df7ad8c --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_Server.h @@ -0,0 +1,96 @@ +// -*- c++ -*- +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// Cubit_Server.h +// +// = DESCRIPTION +// This class implements a simple "cube" CORBA server for the Cubit +// example using skeletons generated by the TAO ORB IDL compiler. +// +// = AUTHORS +// Nagarajan Surendran (naga@cs.wustl.edu) +// +// ============================================================================ + +#if !defined (_CUBIT_SERVER_H) +#define _CUBIT_SERVER_H + +#include "ace/Get_Opt.h" +#include "ace/Log_Msg.h" +#include "tao/TAO.h" +#include "orbsvcs/CosNamingC.h" +#include "orbsvcs/Naming/Naming_Utils.h" +#include "Cubit_Client.h" +#include "Cubit_i.h" + +class Cubit_Server +{ + // = TITLE + // Defines a Cubit Server class that implements the functionality + // of a server process as an object. + // + // = DESCRIPTION + // The interface is quite simple. A server program has to call + // init to initialize the cubit_server's state and then call run + // to run the orb. +public: + // = Initialization and termination methods. + Cubit_Server (void); + // Default constructor + + ~Cubit_Server (void); + // Destructor + + int init (int argc, + char **argv, + CORBA::Environment& env); + // Initialize the Cubit_Server state - parsing arguments and ... + + int run (CORBA::Environment& env); + // Run the orb + +private: + int parse_args (void); + // Parses the commandline arguments. + + int init_naming_service (CORBA::Environment &env); + // Initialises the name server and registers cubit factory with the + // name server. + + int use_naming_service_; + //Flag to tell server not to use the TAO Naming Service to register + //the cubit factory. + + FILE* ior_output_file_; + // File to output the cubit factory IOR. + + TAO_ORB_Manager orb_manager_; + // The ORB manager. + + TAO_Naming_Server my_name_server_; + // An instance of the name server used for registering the factory + // objects. + + Cubit_Factory_i *factory_impl_; + // Implementation object of the cubit factory. + + CosNaming::NamingContext_var cubit_context_; + // Naming context for the cubit_factory. + + CosNaming::NamingContext_var naming_context_; + // Naming context for the Naming Service. + + int argc_; + // Number of commandline arguments. + + char **argv_; + // commandline arguments. +}; + +#endif /* _CUBIT_SERVER_H */ diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp new file mode 100644 index 00000000000..1356da046ea --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.cpp @@ -0,0 +1,332 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// Cubit_Client.cpp +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee and Sergio Flores-Gaitan +// +// ============================================================================ + +#include "tao/corba.h" +#include "ace/Auto_Ptr.h" +#include "Cubit_Client.h" +#include "Cubit_i.h" + +#include "tao/Timeprobe.h" +#include "RTI_IO.h" + +ACE_RCSID(IDL_Cubit, Cubit_Client, "$Id$") + +#if defined (ACE_ENABLE_TIMEPROBES) + +static const char *Cubit_i_Timeprobe_Description[] = +{ + "Cubit_i::cube_oneway - start", + "Cubit_i::cube_oneway - end", + + "Cubit_i::cube_void - start", + "Cubit_i::cube_void - end", + + "Cubit_i::cube_octet - start", + "Cubit_i::cube_octet - end", + + "Cubit_i::cube_short - start", + "Cubit_i::cube_short - end", + + "Cubit_i::cube_long - start", + "Cubit_i::cube_long - end", + + "Cubit_i::cube_struct - start", + "Cubit_i::cube_struct - end", + + "Cubit_i::cube_union - start", + "Cubit_i::cube_union - end", + + "Cubit_i::cube_long_sequence - start", + "Cubit_i::cube_long_sequence - end", + + "Cubit_i::cube_octet_sequence - start", + "Cubit_i::cube_octet_sequence - end" +}; + +enum +{ + // Timeprobe description table start key + CUBIT_I_CUBE_ONEWAY_START = 10100, + CUBIT_I_CUBE_ONEWAY_END, + + CUBIT_I_CUBE_VOID_START, + CUBIT_I_CUBE_VOID_END, + + CUBIT_I_CUBE_OCTET_START, + CUBIT_I_CUBE_OCTET_END, + + CUBIT_I_CUBE_SHORT_START, + CUBIT_I_CUBE_SHORT_END, + + CUBIT_I_CUBE_LONG_START, + CUBIT_I_CUBE_LONG_END, + + CUBIT_I_CUBE_STRUCT_START, + CUBIT_I_CUBE_STRUCT_END, + + CUBIT_I_CUBE_UNION_START, + CUBIT_I_CUBE_UNION_END, + + CUBIT_I_CUBE_LONG_SEQUENCE_START, + CUBIT_I_CUBE_LONG_SEQUENCE_END, + + CUBIT_I_CUBE_OCTET_SEQUENCE_START, + CUBIT_I_CUBE_OCTET_SEQUENCE_END +}; + +// Setup Timeprobes +ACE_TIMEPROBE_EVENT_DESCRIPTIONS (Cubit_i_Timeprobe_Description, + CUBIT_I_CUBE_ONEWAY_START); + +#endif /* ACE_ENABLE_TIMEPROBES */ + +// Constructor + +Cubit_Factory_i::Cubit_Factory_i (CORBA::ORB_ptr orb) + : my_cubit_ (orb) +{ +} + +// Destructor + +Cubit_Factory_i::~Cubit_Factory_i (void) +{ +} + +Cubit_ptr +Cubit_Factory_i::make_cubit (CORBA::Environment &env) +{ + return my_cubit_._this (env); +} + +// Constructor + +Cubit_i::Cubit_i (CORBA::ORB_ptr orb) + : orb_ (CORBA::ORB::_duplicate (orb)) +{ +} + +// Destructor + +Cubit_i::~Cubit_i (void) +{ +} + +void +Cubit_i::cube_oneway (CORBA::Environment &) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_ONEWAY_START); +} + +void +Cubit_i::cube_void (CORBA::Environment &) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_VOID_START); +} + +// Cube an octet + +CORBA::Octet +Cubit_i::cube_octet (CORBA::Octet o, + CORBA::Environment &env) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_OCTET_START); + + ACE_UNUSED_ARG (env); + return o * o * o; +} + +// Cube a short. + +CORBA::Short +Cubit_i::cube_short (CORBA::Short s, + CORBA::Environment &env) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_SHORT_START); + + ACE_UNUSED_ARG (env); + return s * s * s; +} + +// Cube a long + +CORBA::Long +Cubit_i::cube_long (CORBA::Long l, + CORBA::Environment &env) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_START); + + ACE_UNUSED_ARG (env); + return l * l * l; +} + +// Cube a struct + +Cubit::Many +Cubit_i::cube_struct (const Cubit::Many &values, + CORBA::Environment &env) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_STRUCT_START); + + Cubit::Many temp; + + ACE_UNUSED_ARG (env); + temp.o = values.o * values.o * values.o; + temp.s = values.s * values.s * values.s; + temp.l = values.l * values.l * values.l; + + return temp; +} + +// Cube a union + +Cubit::oneof +Cubit_i::cube_union (const Cubit::oneof &values, + CORBA::Environment &env) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_UNION_START); + + Cubit::oneof temp; + + ACE_UNUSED_ARG (env); + switch (values._d ()) + { + case Cubit::e_0th: + temp.o (values.o () * values.o () * values.o ()); + break; + case Cubit::e_1st: + temp.s (values.s () * values.s () * values.s ()); + break; + case Cubit::e_2nd: + temp.l (values.l () * values.l () * values.l ()); + break; + case Cubit::e_3rd: + default: + temp._d (values._d ()); // set the discriminant + // use the read/write accessor + temp.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o; + temp.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s; + temp.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l; + + } + return temp; +} + +// Cube a sequence +void +Cubit_i::cube_long_sequence (const Cubit::long_seq &input, + Cubit::long_seq_out output, + CORBA::Environment &) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_SEQUENCE_START); + + if (output.ptr () == 0) + output = new Cubit::long_seq (input.length ()); + + output->length (input.length ()); + +#if 0 + for (CORBA::ULong i = 0; i < input.length (); ++i) + { + CORBA::Long x = input[i]; + output[i] = x * x * x; + } +#else + CORBA::ULong i = 0; + CORBA::Long x = input[0]; + output[i] = x * x * x; +#endif +} + +// Cube an octet sequence +void +Cubit_i::cube_octet_sequence (const Cubit::octet_seq &input, + Cubit::octet_seq_out output, + CORBA::Environment &) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_OCTET_SEQUENCE_START); + + if (output.ptr () == 0) + { +#if defined (TAO_NO_COPY_OCTET_SEQUENCES) + ACE_Message_Block mb (input.length ()); + mb.wr_ptr (input.length ()); + output = new Cubit::octet_seq (input.length (), &mb); +#else + output = new Cubit::octet_seq (input.length ()); +#endif /* TAO_NO_COPY_OCTET_SEQUENCES */ + } + + output->length (input.length ()); + +#if 0 + for (CORBA::ULong i = 0; i < input.length (); ++i) + { + CORBA::Octet x = input[i]; + output[i] = x * x * x; + } +#else + // We don't want to cube all the elements on the sequence because + // that will take too long and will affect the performance. Further, + // we want to show that octet sequences have constant marshalling + // time, but making a copy of each element will hide that. + CORBA::ULong i = 0; + CORBA::Octet x = input[0]; + output[i] = x * x * x; +#endif +} + +void +Cubit_i::cube_rti_data (const Cubit::RtiPacket &input, + Cubit::RtiPacket_out output, + CORBA::Environment &) +{ + ACE_FUNCTION_TIMEPROBE (CUBIT_I_CUBE_LONG_SEQUENCE_START); + + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + "Input: \n")); + print_RtiPacket (input); + } + + if (output.ptr () == 0) + output = new Cubit::RtiPacket (input); + + output->packetHeader.packetColor + = input.packetHeader.packetColor + * input.packetHeader.packetColor + * input.packetHeader.packetColor; + + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + "Output: \n")); + print_RtiPacket (*output.ptr ()); + } +} + +// Shutdown. + +void Cubit_i::shutdown (CORBA::Environment &env) +{ + ACE_UNUSED_ARG (env); + + ACE_DEBUG ((LM_DEBUG, + "%s\n", + "Cubit_i is shutting down")); + + this->orb_->shutdown (); +} diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h new file mode 100644 index 00000000000..c5af94a59ed --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Cubit_i.h @@ -0,0 +1,111 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// Cubit_Client.h +// +// = AUTHOR +// Andy Gokhale, Sumedh Mungee and Sergio Flores-Gaitan +// +// ============================================================================ + +#if !defined (_CUBIT_I_H) +#define _CUBIT_I_H + +#include "cubitS.h" + +// Forward declarations. +class Cubit_i; + +class Cubit_i : public POA_Cubit +{ + // = TITLE + // Illustrates how to integrate a servant with the generated + // skeleton. + // + // = DESCRIPTION + // Implementation of the cubit example at the servant side. + // Cubes an octet, short, long, struct and union. +public: + Cubit_i (CORBA::ORB_ptr orb); + // Constructor + + ~Cubit_i (void); + // Destructor + + virtual void cube_oneway (CORBA::Environment &env); + // Test a oneway call. + + virtual void cube_void (CORBA::Environment &env); + // Test a twoway call. + + virtual CORBA::Octet cube_octet (CORBA::Octet o, + CORBA::Environment &env); + // Cube an octet + + virtual CORBA::Short cube_short (CORBA::Short s, + CORBA::Environment &env); + // Cube a short + + virtual CORBA::Long cube_long (CORBA::Long l, + CORBA::Environment &env); + // Cube a long + + virtual Cubit::Many cube_struct (const Cubit::Many &values, + CORBA::Environment &env); + // Cube a struct. + + virtual Cubit::oneof cube_union (const Cubit::oneof &values, + CORBA::Environment &env); + // Cube a union. + + virtual void cube_long_sequence (const Cubit::long_seq &input, + Cubit::long_seq_out output, + CORBA::Environment &env); + // Cube a sequence. + + virtual void cube_octet_sequence (const Cubit::octet_seq &input, + Cubit::octet_seq_out output, + CORBA::Environment &_env); + // Cube an octet sequence. + + virtual void cube_rti_data (const Cubit::RtiPacket &input, + Cubit::RtiPacket_out output, + CORBA::Environment &env); + // Cube a sequence. + + virtual void shutdown (CORBA::Environment &env); + // Shutdown routine. + +protected: + + CORBA::ORB_var orb_; + // Keep a pointer to the ORB so we can shut it down. +}; + +class Cubit_Factory_i: public POA_Cubit_Factory +{ + // = TITLE + // Cubit_Factory_i + // + // = DESCRIPTION + // Factory object returning the cubit objrefs +public: + Cubit_Factory_i (CORBA::ORB_ptr orb); + // Constructor. + + ~Cubit_Factory_i (void); + // Destructor. + + virtual Cubit_ptr make_cubit (CORBA::Environment &env); + // Make a cubit object. + +private: + Cubit_i my_cubit_; +}; + +#endif /* _CUBIT_I_H */ diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/IDL_Cubit.dsw b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/IDL_Cubit.dsw new file mode 100644 index 00000000000..2d05ea15b50 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/IDL_Cubit.dsw @@ -0,0 +1,53 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "client"=.\client.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "collocation_test"=.\collocation_test.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "server"=.\server.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/IDL_Cubit_Client.java b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/IDL_Cubit_Client.java new file mode 100644 index 00000000000..eecd5e3a51d --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/IDL_Cubit_Client.java @@ -0,0 +1,122 @@ +// $Id$ +// +// ============================================================================ +// +// = FILENAME +// IDL_Cubit_Client.java +// +// = AUTHOR +// Michael Kircher (mk1@cs.wustl.edu) +// +// = DESCRIPTION +// Connects to the cubit factory, gets a cubit object and +// calls the cube_short method on it. The purpose of this +// class is to demonstrate how to use the JavaIDL ORB to access +// TAO. +// +// ============================================================================ + + +public class IDL_Cubit_Client +{ + + private org.omg.CORBA.ORB orb_; + private org.omg.CORBA.Object naming_service_object_; + + public void init (String[] args) + { + try { + + orb_ = org.omg.CORBA.ORB.init (args, null); + + // Get the Naming Service initial reference + + System.out.println ("Using the lookup protocol!"); + NS_Resolve ns_resolve = new NS_Resolve (); + naming_service_object_ = ns_resolve.resolve_name_service (orb_); + + } + catch(org.omg.CORBA.SystemException e) { + System.err.println ("PushConsumerFactory constructor: ORB and Name Service initialization"); + System.err.println(e); + } + + } + + + public void run () + { + try + { + + // Get the Naming Context to allow resolving the EventService and + // ScheduleService + CosNaming.NamingContext naming_context = + CosNaming.NamingContextHelper.narrow (naming_service_object_); + + if (naming_context == null) + { + System.err.println ("The Naming Context is null"); + System.exit (1); + } + System.out.println ("Reference to the Naming Service is ok."); + + CosNaming.NameComponent[] cubit_factory_name = new CosNaming.NameComponent[2]; + cubit_factory_name[0] = new CosNaming.NameComponent ("IDL_Cubit",""); + cubit_factory_name[1] = new CosNaming.NameComponent ("cubit_factory",""); + org.omg.CORBA.Object factory_obj = naming_context.resolve (cubit_factory_name); + + if (factory_obj == null) + { + System.err.println ("Factory object is nil!"); + return; + } + + Cubit_Factory cubit_Factory = Cubit_FactoryHelper.narrow (factory_obj); + + Cubit cubit = cubit_Factory.make_cubit ("key0"); + + short x = 4; + + System.out.println ("The call cube_short (4) results in: " +cubit.cube_short (x)); + + } + catch (CosNaming.NamingContextPackage.CannotProceed e) + { + System.err.println ("CosNaming.NamingContextPackage.CannotProceed"); + System.err.println (e); + } + catch (CosNaming.NamingContextPackage.InvalidName e) + { + System.err.println ("CosNaming.NamingContextPackage.InvalidName"); + System.err.println (e); + } + catch (CosNaming.NamingContextPackage.NotFound e) + { + System.err.println ("CosNaming.NamingContextPackage.NotFound"); + System.err.println (e); + } + catch(org.omg.CORBA.SystemException e) + { + System.err.println ("PushConsumerFactory.run: Failure"); + System.err.println(e); + } + } + + public static void main (String[] args) { + + IDL_Cubit_Client cubit_Client = new IDL_Cubit_Client (); + cubit_Client.init (args); + + cubit_Client.run (); + } + + +} // public class IDL_Cubit_Client + + + + + + + diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Makefile b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Makefile new file mode 100644 index 00000000000..f650c7be246 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/Makefile @@ -0,0 +1,2787 @@ +#---------------------------------------------------------------------------- +# +# $Id$ +# +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +ifndef TAO_ROOT + TAO_ROOT = $(ACE_ROOT)/TAO +endif # ! TAO_ROOT + +LDLIBS = -lorbsvcs -lTAO + +IDL_SRC = cubitC.cpp cubitS.cpp +PROG_SRCS = Cubit_Server.cpp \ + server.cpp \ + Cubit_Client.cpp \ + collocation_test.cpp \ + client.cpp \ + Cubit_Client.cpp \ + RTI_IO.cpp \ + tmplinst.cpp \ + Cubit_i.cpp + +LSRC = $(IDL_SRC) $(PROG_SRCS) + +CUBIT_SVR_OBJS = cubitC.o \ + cubitS.o \ + Cubit_Server.o \ + Cubit_Client.o \ + Cubit_i.o \ + server.o \ + RTI_IO.o \ + tmplinst.o +CUBIT_CLT_OBJS = cubitC.o \ + cubitS.o \ + Cubit_Client.o \ + client.o \ + RTI_IO.o \ + tmplinst.o +COLLOCATION_OBJS = cubitC.o \ + cubitS.o \ + Cubit_Server.o \ + Cubit_Client.o \ + Cubit_i.o \ + collocation_test.o \ + RTI_IO.o \ + tmplinst.o + +BIN = server \ + client \ + collocation_test +BUILD = $(BIN) +VLDLIBS = $(LDLIBS:%=%$(VAR)) +VBIN = $(BIN:%=%$(VAR)) + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(TAO_ROOT)/rules.tao.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nonested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.local.GNU +include $(TAO_ROOT)/taoconfig.mk + +#---------------------------------------------------------------------------- +# Local targets +#---------------------------------------------------------------------------- + +LDFLAGS += -L$(TAO_ROOT)/orbsvcs/orbsvcs -L$(TAO_ROOT)/tao -L$(TAO_ROOT)/orbsvcs/Naming_Service +CPPFLAGS += -I$(TAO_ROOT)/orbsvcs + +.PRECIOUS: cubitC.cpp cubitS.cpp cubitC.h cubitS.h +#$(IDL_SRC): cubit.idl +# $(TAO_ROOT)/TAO_IDL/tao_idl cubit.idl + +server: $(addprefix $(VDIR),$(CUBIT_SVR_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + +client: $(addprefix $(VDIR),$(CUBIT_CLT_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + +collocation_test: $(addprefix $(VDIR),$(COLLOCATION_OBJS)) + $(LINK.cc) $(LDFLAGS) -o $@ $^ $(VLDLIBS) $(POSTLINK) + +realclean: clean + -/bin/rm -rf cubitC.* cubitS.* cubitS_T.* + +# DO NOT DELETE THIS LINE -- g++dep uses it. +# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY. + +.obj/cubitC.o .obj/cubitC.so .shobj/cubitC.o .shobj/cubitC.so: cubitC.cpp cubitC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + cubitC.i cubitS.h cubitS_T.h cubitS_T.i cubitS_T.cpp cubitS.i +.obj/cubitS.o .obj/cubitS.so .shobj/cubitS.o .shobj/cubitS.so: cubitS.cpp cubitS.h cubitC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + cubitC.i cubitS_T.h cubitS_T.i cubitS_T.cpp cubitS.i +.obj/Cubit_Server.o .obj/Cubit_Server.so .shobj/Cubit_Server.o .shobj/Cubit_Server.so: Cubit_Server.cpp Cubit_Server.h \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(TAO_ROOT)/tao/TAO.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/orbsvcs_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/CosNaming_i.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Entries.h \ + Cubit_Client.h \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + cubitC.h cubitC.i Cubit_i.h cubitS.h cubitS_T.h cubitS_T.i \ + cubitS_T.cpp cubitS.i +.obj/server.o .obj/server.so .shobj/server.o .shobj/server.so: server.cpp Cubit_Server.h \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(TAO_ROOT)/tao/TAO.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/orbsvcs_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/CosNaming_i.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Entries.h \ + Cubit_Client.h \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + cubitC.h cubitC.i Cubit_i.h cubitS.h cubitS_T.h cubitS_T.i \ + cubitS_T.cpp cubitS.i \ + $(TAO_ROOT)/tao/Timeprobe.h \ + $(ACE_ROOT)/ace/Timeprobe.h +.obj/Cubit_Client.o .obj/Cubit_Client.so .shobj/Cubit_Client.o .shobj/Cubit_Client.so: Cubit_Client.cpp \ + $(ACE_ROOT)/ace/Env_Value_T.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Env_Value_T.i \ + $(ACE_ROOT)/ace/Env_Value_T.cpp \ + $(ACE_ROOT)/ace/Read_Buffer.h \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Read_Buffer.i \ + Cubit_Client.h \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + cubitC.h cubitC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/orbsvcs_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/CosNaming_i.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Entries.h \ + $(TAO_ROOT)/tao/Timeprobe.h \ + $(ACE_ROOT)/ace/Timeprobe.h \ + RTI_IO.h +.obj/collocation_test.o .obj/collocation_test.so .shobj/collocation_test.o .shobj/collocation_test.so: collocation_test.cpp \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + Cubit_Client.h \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + cubitC.h cubitC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/orbsvcs_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/CosNaming_i.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Entries.h \ + Cubit_Server.h \ + $(TAO_ROOT)/tao/TAO.h \ + Cubit_i.h cubitS.h cubitS_T.h cubitS_T.i cubitS_T.cpp cubitS.i +.obj/client.o .obj/client.so .shobj/client.o .shobj/client.so: client.cpp Cubit_Client.h \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + cubitC.h cubitC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/orbsvcs_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/CosNaming_i.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Entries.h \ + $(TAO_ROOT)/tao/Timeprobe.h \ + $(ACE_ROOT)/ace/Timeprobe.h +.obj/Cubit_Client.o .obj/Cubit_Client.so .shobj/Cubit_Client.o .shobj/Cubit_Client.so: Cubit_Client.cpp \ + $(ACE_ROOT)/ace/Env_Value_T.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Env_Value_T.i \ + $(ACE_ROOT)/ace/Env_Value_T.cpp \ + $(ACE_ROOT)/ace/Read_Buffer.h \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Read_Buffer.i \ + Cubit_Client.h \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + cubitC.h cubitC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/orbsvcs_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/CosNaming_i.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Entries.h \ + $(TAO_ROOT)/tao/Timeprobe.h \ + $(ACE_ROOT)/ace/Timeprobe.h \ + RTI_IO.h +.obj/RTI_IO.o .obj/RTI_IO.so .shobj/RTI_IO.o .shobj/RTI_IO.so: RTI_IO.cpp RTI_IO.h cubitC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + cubitC.i +.obj/tmplinst.o .obj/tmplinst.so .shobj/tmplinst.o .shobj/tmplinst.so: tmplinst.cpp cubitC.h \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + cubitC.i +.obj/Cubit_i.o .obj/Cubit_i.so .shobj/Cubit_i.o .shobj/Cubit_i.so: Cubit_i.cpp \ + $(TAO_ROOT)/tao/corba.h \ + $(TAO_ROOT)/tao/orbconf.h \ + $(ACE_ROOT)/ace/OS.h \ + $(ACE_ROOT)/ace/inc_user_config.h \ + $(ACE_ROOT)/ace/config.h \ + $(ACE_ROOT)/ace/config-sunos5.5.h \ + $(ACE_ROOT)/ace/config-g++-common.h \ + $(ACE_ROOT)/ace/streams.h \ + $(ACE_ROOT)/ace/Basic_Types.h \ + $(ACE_ROOT)/ace/Basic_Types.i \ + $(ACE_ROOT)/ace/OS.i \ + $(ACE_ROOT)/ace/Trace.h \ + $(ACE_ROOT)/ace/Log_Msg.h \ + $(ACE_ROOT)/ace/Log_Record.h \ + $(ACE_ROOT)/ace/ACE.h \ + $(ACE_ROOT)/ace/ACE.i \ + $(ACE_ROOT)/ace/Log_Priority.h \ + $(ACE_ROOT)/ace/Log_Record.i \ + $(ACE_ROOT)/ace/Get_Opt.h \ + $(ACE_ROOT)/ace/Get_Opt.i \ + $(ACE_ROOT)/ace/SOCK_Stream.h \ + $(ACE_ROOT)/ace/SOCK_IO.h \ + $(ACE_ROOT)/ace/SOCK.h \ + $(ACE_ROOT)/ace/Addr.h \ + $(ACE_ROOT)/ace/Addr.i \ + $(ACE_ROOT)/ace/IPC_SAP.h \ + $(ACE_ROOT)/ace/IPC_SAP.i \ + $(ACE_ROOT)/ace/SOCK.i \ + $(ACE_ROOT)/ace/SOCK_IO.i \ + $(ACE_ROOT)/ace/INET_Addr.h \ + $(ACE_ROOT)/ace/INET_Addr.i \ + $(ACE_ROOT)/ace/SOCK_Stream.i \ + $(ACE_ROOT)/ace/Synch_T.h \ + $(ACE_ROOT)/ace/Event_Handler.h \ + $(ACE_ROOT)/ace/Event_Handler.i \ + $(ACE_ROOT)/ace/Synch.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.h \ + $(ACE_ROOT)/ace/SV_Semaphore_Simple.i \ + $(ACE_ROOT)/ace/SV_Semaphore_Complex.i \ + $(ACE_ROOT)/ace/Synch.i \ + $(ACE_ROOT)/ace/Synch_T.i \ + $(ACE_ROOT)/ace/Thread.h \ + $(ACE_ROOT)/ace/Thread.i \ + $(ACE_ROOT)/ace/Atomic_Op.i \ + $(ACE_ROOT)/ace/Synch_T.cpp \ + $(ACE_ROOT)/ace/Hash_Map_Manager.h \ + $(ACE_ROOT)/ace/Hash_Map_Manager.cpp \ + $(ACE_ROOT)/ace/Service_Config.h \ + $(ACE_ROOT)/ace/Service_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.h \ + $(ACE_ROOT)/ace/Shared_Object.i \ + $(ACE_ROOT)/ace/Service_Object.i \ + $(ACE_ROOT)/ace/Signal.h \ + $(ACE_ROOT)/ace/Containers.h \ + $(ACE_ROOT)/ace/Containers.i \ + $(ACE_ROOT)/ace/Containers.cpp \ + $(ACE_ROOT)/ace/Malloc.h \ + $(ACE_ROOT)/ace/Malloc_Base.h \ + $(ACE_ROOT)/ace/Malloc.i \ + $(ACE_ROOT)/ace/Malloc_T.h \ + $(ACE_ROOT)/ace/Free_List.h \ + $(ACE_ROOT)/ace/Free_List.i \ + $(ACE_ROOT)/ace/Free_List.cpp \ + $(ACE_ROOT)/ace/Malloc_T.i \ + $(ACE_ROOT)/ace/Malloc_T.cpp \ + $(ACE_ROOT)/ace/Memory_Pool.h \ + $(ACE_ROOT)/ace/Mem_Map.h \ + $(ACE_ROOT)/ace/Mem_Map.i \ + $(ACE_ROOT)/ace/Memory_Pool.i \ + $(ACE_ROOT)/ace/Signal.i \ + $(ACE_ROOT)/ace/Object_Manager.h \ + $(ACE_ROOT)/ace/Object_Manager.i \ + $(ACE_ROOT)/ace/Managed_Object.h \ + $(ACE_ROOT)/ace/Managed_Object.i \ + $(ACE_ROOT)/ace/Managed_Object.cpp \ + $(ACE_ROOT)/ace/SString.h \ + $(ACE_ROOT)/ace/SString.i \ + $(ACE_ROOT)/ace/Service_Config.i \ + $(ACE_ROOT)/ace/Reactor.h \ + $(ACE_ROOT)/ace/Handle_Set.h \ + $(ACE_ROOT)/ace/Handle_Set.i \ + $(ACE_ROOT)/ace/Timer_Queue.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.h \ + $(ACE_ROOT)/ace/Timer_Queue_T.i \ + $(ACE_ROOT)/ace/Timer_Queue_T.cpp \ + $(ACE_ROOT)/ace/Reactor.i \ + $(ACE_ROOT)/ace/Reactor_Impl.h \ + $(ACE_ROOT)/ace/Svc_Conf_Tokens.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.h \ + $(ACE_ROOT)/ace/Time_Value.h \ + $(ACE_ROOT)/ace/SOCK_Acceptor.i \ + $(ACE_ROOT)/ace/SOCK_Connector.h \ + $(ACE_ROOT)/ace/SOCK_Connector.i \ + $(ACE_ROOT)/ace/Strategies.h \ + $(ACE_ROOT)/ace/Strategies_T.h \ + $(ACE_ROOT)/ace/Synch_Options.h \ + $(ACE_ROOT)/ace/Synch_Options.i \ + $(ACE_ROOT)/ace/Thread_Manager.h \ + $(ACE_ROOT)/ace/Thread_Manager.i \ + $(ACE_ROOT)/ace/Strategies_T.i \ + $(ACE_ROOT)/ace/Strategies_T.cpp \ + $(ACE_ROOT)/ace/Service_Repository.h \ + $(ACE_ROOT)/ace/Service_Types.h \ + $(ACE_ROOT)/ace/Service_Types.i \ + $(ACE_ROOT)/ace/Service_Repository.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.h \ + $(ACE_ROOT)/ace/Message_Queue.h \ + $(ACE_ROOT)/ace/Message_Block.h \ + $(ACE_ROOT)/ace/Message_Block.i \ + $(ACE_ROOT)/ace/IO_Cntl_Msg.h \ + $(ACE_ROOT)/ace/Message_Queue_T.h \ + $(ACE_ROOT)/ace/Message_Queue_T.i \ + $(ACE_ROOT)/ace/Message_Queue_T.cpp \ + $(ACE_ROOT)/ace/Message_Queue.i \ + $(ACE_ROOT)/ace/WFMO_Reactor.i \ + $(ACE_ROOT)/ace/Strategies.i \ + $(ACE_ROOT)/ace/Connector.h \ + $(ACE_ROOT)/ace/Map_Manager.h \ + $(ACE_ROOT)/ace/Map_Manager.i \ + $(ACE_ROOT)/ace/Map_Manager.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.h \ + $(ACE_ROOT)/ace/Task.h \ + $(ACE_ROOT)/ace/Task.i \ + $(ACE_ROOT)/ace/Task_T.h \ + $(ACE_ROOT)/ace/Task_T.i \ + $(ACE_ROOT)/ace/Task_T.cpp \ + $(ACE_ROOT)/ace/Module.h \ + $(ACE_ROOT)/ace/Module.i \ + $(ACE_ROOT)/ace/Module.cpp \ + $(ACE_ROOT)/ace/Stream_Modules.h \ + $(ACE_ROOT)/ace/Stream_Modules.i \ + $(ACE_ROOT)/ace/Stream_Modules.cpp \ + $(ACE_ROOT)/ace/Svc_Handler.i \ + $(ACE_ROOT)/ace/Svc_Handler.cpp \ + $(ACE_ROOT)/ace/Dynamic.h \ + $(ACE_ROOT)/ace/Singleton.h \ + $(ACE_ROOT)/ace/Singleton.i \ + $(ACE_ROOT)/ace/Singleton.cpp \ + $(ACE_ROOT)/ace/Dynamic.i \ + $(ACE_ROOT)/ace/Connector.i \ + $(ACE_ROOT)/ace/Connector.cpp \ + $(ACE_ROOT)/ace/Acceptor.h \ + $(ACE_ROOT)/ace/Acceptor.i \ + $(ACE_ROOT)/ace/Acceptor.cpp \ + $(TAO_ROOT)/tao/Align.h \ + $(TAO_ROOT)/tao/Environment.h \ + $(TAO_ROOT)/tao/Environment.i \ + $(TAO_ROOT)/tao/ORB.h \ + $(TAO_ROOT)/tao/Sequence.h \ + $(TAO_ROOT)/tao/Sequence.i \ + $(TAO_ROOT)/tao/Sequence_T.h \ + $(TAO_ROOT)/tao/Sequence_T.i \ + $(TAO_ROOT)/tao/Sequence_T.cpp \ + $(TAO_ROOT)/tao/Object_KeyC.h \ + $(TAO_ROOT)/tao/Object_KeyC.i \ + $(TAO_ROOT)/tao/Union.h \ + $(TAO_ROOT)/tao/ORB.i \ + $(TAO_ROOT)/tao/Exception.h \ + $(TAO_ROOT)/tao/Exception.i \ + $(TAO_ROOT)/tao/Any.h \ + $(TAO_ROOT)/tao/Any.i \ + $(TAO_ROOT)/tao/NVList.h \ + $(TAO_ROOT)/tao/NVList.i \ + $(TAO_ROOT)/tao/Principal.h \ + $(TAO_ROOT)/tao/Principal.i \ + $(TAO_ROOT)/tao/Request.h \ + $(TAO_ROOT)/tao/Request.i \ + $(TAO_ROOT)/tao/Stub.h \ + $(TAO_ROOT)/tao/Stub.i \ + $(TAO_ROOT)/tao/Object.h \ + $(TAO_ROOT)/tao/Object.i \ + $(TAO_ROOT)/tao/varout.h \ + $(TAO_ROOT)/tao/varout.i \ + $(TAO_ROOT)/tao/varout.cpp \ + $(TAO_ROOT)/tao/Typecode.h \ + $(TAO_ROOT)/tao/Typecode.i \ + $(TAO_ROOT)/tao/Marshal.h \ + $(TAO_ROOT)/tao/Marshal.i \ + $(TAO_ROOT)/tao/singletons.h \ + $(TAO_ROOT)/tao/CDR.h \ + $(TAO_ROOT)/tao/CDR.i \ + $(TAO_ROOT)/tao/PolicyC.h \ + $(TAO_ROOT)/tao/PolicyC.i \ + $(TAO_ROOT)/tao/CurrentC.h \ + $(TAO_ROOT)/tao/CurrentC.i \ + $(TAO_ROOT)/tao/POA.h \ + $(TAO_ROOT)/tao/POAC.h \ + $(TAO_ROOT)/tao/POAC.i \ + $(TAO_ROOT)/tao/Servant_Base.h \ + $(TAO_ROOT)/tao/POAS.h \ + $(TAO_ROOT)/tao/POA_CORBA.h \ + $(TAO_ROOT)/tao/POAS.i \ + $(TAO_ROOT)/tao/Object_Table.h \ + $(TAO_ROOT)/tao/POA.i \ + $(TAO_ROOT)/tao/poa_macros.h \ + $(TAO_ROOT)/tao/params.h \ + $(TAO_ROOT)/tao/params.i \ + $(TAO_ROOT)/tao/Connect.h \ + $(TAO_ROOT)/tao/Connect.i \ + $(TAO_ROOT)/tao/ORB_Core.h \ + $(TAO_ROOT)/tao/ORB_Core.i \ + $(ACE_ROOT)/ace/Dynamic_Service.h \ + $(ACE_ROOT)/ace/Dynamic_Service.cpp \ + $(TAO_ROOT)/tao/Operation_Table.h \ + $(TAO_ROOT)/tao/debug.h \ + $(TAO_ROOT)/tao/Client_Strategy_Factory.h \ + $(TAO_ROOT)/tao/Server_Strategy_Factory.h \ + $(TAO_ROOT)/tao/default_client.h \ + $(TAO_ROOT)/tao/default_client.i \ + $(TAO_ROOT)/tao/default_server.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.h \ + $(TAO_ROOT)/tao/ORB_Strategies_T.i \ + $(TAO_ROOT)/tao/ORB_Strategies_T.cpp \ + $(TAO_ROOT)/tao/default_server.i \ + $(TAO_ROOT)/tao/IIOP_Object.h \ + $(TAO_ROOT)/tao/IIOP_Object.i \ + $(TAO_ROOT)/tao/IIOP_ORB.h \ + $(TAO_ROOT)/tao/IIOP_ORB.i \ + $(TAO_ROOT)/tao/IIOP_Interpreter.h \ + $(TAO_ROOT)/tao/GIOP.h \ + $(TAO_ROOT)/tao/GIOP.i \ + $(TAO_ROOT)/tao/Invocation.h \ + $(TAO_ROOT)/tao/Invocation.i \ + $(TAO_ROOT)/tao/Server_Request.h \ + $(TAO_ROOT)/tao/Server_Request.i \ + $(ACE_ROOT)/ace/Auto_Ptr.h \ + $(ACE_ROOT)/ace/Auto_Ptr.i \ + $(ACE_ROOT)/ace/Auto_Ptr.cpp \ + Cubit_Client.h \ + $(ACE_ROOT)/ace/Profile_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.h \ + $(ACE_ROOT)/ace/High_Res_Timer.i \ + $(ACE_ROOT)/ace/Profile_Timer.i \ + cubitC.h cubitC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Naming_Utils.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/orbsvcs_export.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingC.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/IOR_Multicast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.h \ + $(ACE_ROOT)/ace/SOCK_Dgram.i \ + $(ACE_ROOT)/ace/SOCK_Dgram_Mcast.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/CosNaming_i.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.h \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS_T.cpp \ + $(TAO_ROOT)/orbsvcs/orbsvcs/CosNamingS.i \ + $(TAO_ROOT)/orbsvcs/orbsvcs/Naming/Entries.h \ + Cubit_i.h cubitS.h cubitS_T.h cubitS_T.i cubitS_T.cpp cubitS.i \ + $(TAO_ROOT)/tao/Timeprobe.h \ + $(ACE_ROOT)/ace/Timeprobe.h \ + RTI_IO.h + +# IF YOU PUT ANYTHING HERE IT WILL GO AWAY diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/README b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/README new file mode 100644 index 00000000000..ca173cc45ab --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/README @@ -0,0 +1,169 @@ +// $Id$ + +This example uses the TAO IDL compiler to generate the SII stubs and +skeletons. You can either run the server in the background in the +same window as the client or open a separate window for the client and +server. + +By default, the client and server use the Naming Service. The cubit +server has its own NamingServer implementation. Therefore, you don't +have to start the NamingService before starting the client and server. +Likewise, you can use the -s flags on both the server and client if +you don't want to use the naming service. + +The collocation_test demonstrates how the performance improves when +objects are collocated. The test runs both server and client in +different threads. To run it, simply run collocation_test. It +accepts any command line arguments for the client side, but there is +not way to specify command line arguments for the server side at this +moment. This may be changed in the future. At this moment, the +collocation_test must use Naming_Service to resolve object +references. This may be changed later, also. + +server: +------- + +% server [-d] [-s] [-ORBhost <serverhost>] [-ORBport <portnum>] + [-n <number-of-cubit-objects>] [-o <ior_output_file>] + +Options: +------- +-s Tells the server not to register the Cubit_Factory object + with the Naming Service. + +-d Debug flag (It is additive more -d flags will increase + the debugging level). + +-o Outputs the cubit_factory IOR to a file. + +-n Number of cubit objects exported by the server. + +The server cubit factory maintains num_of_cubit objects (default = +1). They are assigned keys that look like "key0", "key1", ... + +When the server is started and you have used the -d flag, you should +see as the first line of output something that looks like the follow: + + iiop:1.0//swarm:10015/Persistent/886013035/850128/RootPOA/RootPOA_is_BAD/factory + (-ORBobjrefstyle url) +or + IOR:000000000000001649444c3a43756269745... + (-ORBobjrefstyle ior) + +Using -d turns on debugging messages. It is additive, i.e., the more +-d options provided, the more debugging you get. At the moment, only +2 levels of debugging are implemented, and more than 2 -d options are +silently ignored. + +client: +------- + +% client [-d] [-s] [-x] <-f cubit_factory_ior_file> <-k cubit_factory_ior> -n <iterations> + +Options: +------- +-d Debug flag +-s Don't Use the Naming Service +-x Tells the server to shutdown. +-f Reads the cubit factory IOR from the file +-k Reads the cubit factory IOR from commandline +-n no. of iterations + +The following are the three ways of giving the CubitFactory IOR to the +client: + + 1. From a file using the -f option. (This file can be produced using + the -o option of the server.) + + 2. Directly on the commandline using the -k option. + + 3. Get it from the Naming Service (which is the default client + behavior). + +collocation_test: +----------------- + + This test demonstrates how collocation optimization improve +performance of collocated objects. Run the test without any argument +to see results with collocation optimization. Run it with +<-ORBcollocation no> to perform the same test without the optimization. + +run_test.pl: +------------ + + This is a perl script which simplifies the execution of the +test. + +run_test [-h] [-n num] [-mcast] [-sleeptime t] [-debug] [-release] + +-h -- prints this information +-n num -- client uses <num> iterations +-mcast -- uses the multicast version of the nameservice +-sleeptime t -- run_test should sleep for <t> seconds between running + the server and client +-debug -- sets the debug flag for both client and server +-release -- runs the Release version of the test (for NT use) + (default is 3 seconds) + +Sample Run-Using files to communicate IOR: +------------------------------------------ + +1. Start the server. + +% server -s -ORBport 20000 -ORBobjrefstyle url -o theior + + IDL_Cubit:SERVER + +The IOR is: <iiop:1.0//tango:20000/Persistent/887665222/647179/RootPOA/RootPOA_is_BAD/factory\00\00> + +2. Start the client. + +%client -s -ORBport 19998 -f theior + + IDL_Cubit: client + +Factory received OK +. +. +. + +Sample Run-Using Naming Service: +-------------------------------- +1. Start the server + %server -ORBport 19999 + +2. Start the client + %client -ORBport 19998 + if you don't want the server to shutdown. + %client -ORBport 19998 -x + if you want to shutdown the server after this request. + +3. If Multicast is not supported the naming service can be reached by +the following 2 methods. + + a) use the -ORBnameserviceior flag to the client to give the + naming service ior outputted by the server. + + b)set the ENVIRONMENT variable "NameService" + + This might be helpful if more than one person is running the + Naming service in which case Multicast might cause confusion with some + other Naming Service trying to answer your call. + +Using JAVA to access the IDL Cubit test: +---------------------------------------- + +install JDK1.2 +install Java to IDL compiler + +copy the following files: +cp $TAO_ROOT/orbsvcs/orbsvcs/CosNaming.idl . +cp $TAO_ROOT/orbsvcs/tests/Simulator/DOVEBrowser/NS_Resolve.java . + +Compile: +javatoidl cubit.idl +javatoidl CosNaming.idl +javac *.java + +Run: +java IDL_Cubit_Client diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/RTI_IO.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/RTI_IO.cpp new file mode 100644 index 00000000000..6354965095c --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/RTI_IO.cpp @@ -0,0 +1,55 @@ +// $Id$ + +#include "RTI_IO.h" + +void +print_RtiPacket (Cubit::RtiPacket const &arg) +{ + ACE_DEBUG ((LM_DEBUG, + "packetHeader.packetLength %d\n" + "packetHeader.federationHandle %d\n" + "packetHeader.channelHandle %d\n" + "packetHeader.packetColor %d\n", + arg.packetHeader.packetLength, + arg.packetHeader.federationHandle, + arg.packetHeader.channelHandle, + arg.packetHeader.packetColor)); + + for (CORBA::ULong j = 0; j < arg.msgs.length (); ++j) + { + ACE_DEBUG ((LM_DEBUG, + "* message * %d\n", + j)); + + Cubit::RtiObjectUpdateMessageHeader const &oumh = arg.msgs[j].oumh (); + + ACE_DEBUG ((LM_DEBUG, + "\tupdateLength: %d\n" + "\tupdateTag: %d\n" + "\tobjectHandle: %d\n" + "\ttimestamp: %f\n" + //"\teventRetractionHandle: \n" + "\tclassHandle: %d\n" + "\tsendingFederateHandle: %d\n" + "\tuserTag: %s\n" + "\ttransportationHandle: %x\n" + "\torderingHandle: %x\n", + oumh.updateLength, + oumh.updateTag, + oumh.objectHandle, + oumh.timestamp, + //oumh.eventRetractionHandle, + oumh.classHandle, + oumh.sendingFederateHandle, + oumh.userTag.in (), + oumh.transportationHandle, + oumh.orderingHandle)); + + for (CORBA::ULong k = 0; k < oumh.messagePayload.length (); ++k) + { + Cubit::HandleValuePair const & hvp=oumh.messagePayload[k]; + ACE_DEBUG ((LM_DEBUG, "\t\thandle: %d\n", hvp.handle)); + } + } + +} diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/RTI_IO.h b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/RTI_IO.h new file mode 100644 index 00000000000..9793c60632b --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/RTI_IO.h @@ -0,0 +1,23 @@ +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// TAO/tests/IDL_Cubit +// +// = FILENAME +// RTI_IO.h +// +// = AUTHOR +// Dave Meyer <dmeyer@std.saic.com> +// +// ============================================================================ + +#if !defined (_RTIFUNCS_H) +#define _RTIFUNCS_H + +#include "cubitC.h" + +void print_RtiPacket (Cubit::RtiPacket const &arg); + +#endif /* _RTIFUNCS_H */ diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.bld b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.bld new file mode 100644 index 00000000000..9b912e57dd0 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.bld @@ -0,0 +1,12 @@ +#!build +default: + program + :debuglevel=multi +cubitC.cpp + C++ +cubitS.cpp + C++ +client.cpp + C++ +tmplinst.cpp + C++ diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.cpp new file mode 100644 index 00000000000..5f2a798b6ac --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.cpp @@ -0,0 +1,27 @@ +// $Id$ + +#include "Cubit_Client.h" +#include "tao/Timeprobe.h" + +ACE_RCSID(IDL_Cubit, client, "$Id$") + +// This function runs the client test. + +int +main (int argc, char **argv) +{ + Cubit_Client cubit_client; + + ACE_DEBUG ((LM_DEBUG, + "\n\tIDL_Cubit: client\n\n")); + + if (cubit_client.init (argc, argv) == -1) + return 1; + + int retval = cubit_client.run (); + + ACE_TIMEPROBE_PRINT; + + return retval; +} + diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.dsp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.dsp new file mode 100644 index 00000000000..2bc99bd8ad1 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/client.dsp @@ -0,0 +1,216 @@ +# Microsoft Developer Studio Project File - Name="IDL_Cubit Client" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=IDL_Cubit Client - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak" CFG="IDL_Cubit Client - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "IDL_Cubit Client - Win32 Release" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE "IDL_Cubit Client - Win32 Debug" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "IDL_Cubit Client - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\client\Release"
+# PROP BASE Intermediate_Dir ".\client\Release"
+# PROP BASE Target_Dir ".\client"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ".\client"
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D TAO_ORBSVCS_HAS_DLL=1 /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ace.lib TAO.lib orbsvcs.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\tao\\" /libpath:"..\..\..\..\..\ace" /libpath:"..\..\..\..\orbsvcs\orbsvcs"
+
+!ELSEIF "$(CFG)" == "IDL_Cubit Client - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\client\Debug"
+# PROP BASE Intermediate_Dir ".\client\Debug"
+# PROP BASE Target_Dir ".\client"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ".\client"
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D TAO_ORBSVCS_HAS_DLL=1 /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+# ADD LINK32 aced.lib TAOd.lib orbsvcsd.lib /nologo /subsystem:console /debug /machine:I386 /libpath:"..\..\..\..\tao" /libpath:"..\..\..\..\..\ace" /libpath:"..\..\..\..\orbsvcs\orbsvcs"
+
+!ENDIF
+
+# Begin Target
+
+# Name "IDL_Cubit Client - Win32 Release"
+# Name "IDL_Cubit Client - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RTI_IO.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Cubit_Client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\cubit.idl
+
+!IF "$(CFG)" == "IDL_Cubit Client - Win32 Release"
+
+USERDEP__CUBIT="..\..\..\..\tao_idl\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\Release\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "IDL_Cubit Client - Win32 Debug"
+
+USERDEP__CUBIT="..\..\..\..\tao_idl\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp new file mode 100644 index 00000000000..67fc63f8f52 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.cpp @@ -0,0 +1,70 @@ +// $Id$ + +#include "ace/Synch.h" +#include "Cubit_Client.h" +#include "Cubit_Server.h" + +ACE_RCSID(IDL_Cubit, collocation_test, "$Id$") + +#define ACE_THREAD_MANAGER ACE_Thread_Manager::instance () + +void * +svr_worker (void *arg) +{ + Cubit_Server cubit_server; + ACE_Barrier *barrier = (ACE_Barrier *) arg; + char *fake[] = {"server"}; + + TAO_TRY + { + if (cubit_server.init (1, fake, TAO_TRY_ENV) == -1) + return (void *) 1; + else + { + barrier->wait (); + cubit_server.run (TAO_TRY_ENV); + } + TAO_CHECK_ENV; + } + TAO_CATCH (CORBA::SystemException, sysex) + { + ACE_UNUSED_ARG (sysex); + TAO_TRY_ENV.print_exception ("System Exception"); + return (void *) 1; + } + TAO_CATCH (CORBA::UserException, userex) + { + ACE_UNUSED_ARG (userex); + TAO_TRY_ENV.print_exception ("User Exception"); + return (void *) 1; + } + TAO_ENDTRY; + return 0; +} + + +int +main (int argc, char **argv) +{ + Cubit_Client cubit_client; + CORBA::Environment env; + ACE_Barrier barrier (2); + + int retv = 1; + + ACE_DEBUG ((LM_DEBUG, + "\n \t IDL_Cubit: Collocation test \n\n")); + + ACE_THREAD_MANAGER->spawn (ACE_reinterpret_cast (ACE_THR_FUNC, &svr_worker), + &barrier); + barrier.wait (); + ACE_OS::sleep (1); + + if (cubit_client.init (argc, argv) == -1) + return 1; + else + retv = cubit_client.run (1); + + ACE_THREAD_MANAGER->wait (); + return retv; +} diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.dsp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.dsp new file mode 100644 index 00000000000..48c2ac45270 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/collocation_test.dsp @@ -0,0 +1,233 @@ +# Microsoft Developer Studio Project File - Name="IDL_Cubit Collocation Test" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=IDL_Cubit Collocation Test - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "collocation_test.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "collocation_test.mak"\
+ CFG="IDL_Cubit Collocation Test - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "IDL_Cubit Collocation Test - Win32 Release" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE "IDL_Cubit Collocation Test - Win32 Debug" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "IDL_Cubit Collocation Test - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "collocat"
+# PROP BASE Intermediate_Dir "collocat"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D TAO_ORBSVCS_HAS_DLL=1 /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ace.lib TAO.lib orbsvcs.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\tao\\" /libpath:"..\..\..\..\..\ace" /libpath:"..\..\..\..\orbsvcs\orbsvcs"
+
+!ELSEIF "$(CFG)" == "IDL_Cubit Collocation Test - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "colloca0"
+# PROP BASE Intermediate_Dir "colloca0"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /D TAO_ORBSVCS_HAS_DLL=1 /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 aced.lib TAOd.lib orbsvcsd.lib /nologo /subsystem:console /debug /machine:I386 /libpath:"..\..\..\..\tao\\" /libpath:"..\..\..\..\..\ace" /libpath:"..\..\..\..\orbsvcs\orbsvcs"
+
+!ENDIF
+
+# Begin Target
+
+# Name "IDL_Cubit Collocation Test - Win32 Release"
+# Name "IDL_Cubit Collocation Test - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;idl"
+# Begin Source File
+
+SOURCE=.\collocation_test.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_i.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Server.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RTI_IO.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h"
+# Begin Source File
+
+SOURCE=.\Cubit_Client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Server.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\cubit.idl
+
+!IF "$(CFG)" == "IDL_Cubit Collocation Test - Win32 Release"
+
+USERDEP__CUBIT="..\..\..\..\tao_idl\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\Release\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "IDL_Cubit Collocation Test - Win32 Debug"
+
+USERDEP__CUBIT="..\..\..\..\tao_idl\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/cubit.idl b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/cubit.idl new file mode 100644 index 00000000000..7f6e87ea8d8 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/cubit.idl @@ -0,0 +1,153 @@ +/* -*- C++ -*- */ +// $Id$ + +interface Cubit +{ + // = TITLE + // Defines an interface that encapsulates operations that cube + // numbers. + // + // = DESCRIPTION + // This interface encapsulates operations that cube + // octets, shorts, longs, structs and unions. + + oneway void cube_oneway (); + // Test the basic latency of a nil oneway operation. + + void cube_void (); + // Test the basic latency of a nil operation. + + octet cube_octet (in octet o); + // cube an octet + + short cube_short (in short s); + // cube a short + + long cube_long (in long l); + // cube a long + + struct Many + { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + // Cube a struct + + enum discrim + { + e_0th, + e_1st, + e_2nd, + e_3rd + }; + // Enumeration of the different elements in a union. + + union oneof switch (discrim) + { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + Many cm; + + // default: + // Many cm; + }; + // Union of different types. + + oneof cube_union (in oneof values); + // cube a union. + + typedef sequence<long> long_seq; + + void cube_long_sequence (in long_seq input, + out long_seq output); + // Cube several longs. + + + typedef sequence<octet> octet_seq; + void cube_octet_sequence (in octet_seq input, out octet_seq output); + // Cube an octet sequence. + + oneway void shutdown (); + // shutdown the application. + + // = The following types provide a torture-test for structs. + struct RtiPacketHeader + { + unsigned long packetLength; // this is probably redundant + unsigned short federationHandle; + unsigned long channelHandle; + unsigned long packetColor; + }; + + struct HandleValuePair + { + unsigned short handle; + octet_seq data; + }; + + enum MessageHeaderTypes + { + objectUpdate, + interaction + // others omitted + }; + + typedef sequence<HandleValuePair> HandleValuePairSeq; + struct RtiObjectUpdateMessageHeader + { + unsigned long updateLength; // probably redundant + unsigned long updateTag; + unsigned long objectHandle; + double timestamp; + unsigned long long eventRetractionHandle; + unsigned short classHandle; + unsigned short sendingFederateHandle; + string userTag; + octet_seq regionData; + octet transportationHandle; + octet orderingHandle; + HandleValuePairSeq messagePayload; + }; + + struct RtiInteractionMessageHeader + { + unsigned long updateLength; + // similar to object update + }; + + union MessageUnion switch(MessageHeaderTypes) + { + case objectUpdate: + RtiObjectUpdateMessageHeader oumh; + case interaction: + RtiInteractionMessageHeader imh; + }; + + typedef sequence <MessageUnion> MessageUnionSeq; + struct RtiPacket + { + RtiPacketHeader packetHeader; + MessageUnionSeq msgs; + }; + + void cube_rti_data (in RtiPacket input, + out RtiPacket output); +}; + +interface Cubit_Factory +{ + // = TITLE + // Creates Cubit objects. + + Cubit make_cubit (); +}; diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/default.bld b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/default.bld new file mode 100644 index 00000000000..c678d14dca1 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/default.bld @@ -0,0 +1,32 @@ +#!build +default: + nobuild + :c_option=slashcomment + :cx_e_option=msgnumbers + :object_dir=./obj + :target=vxwppc + :cx_silent=21 + :cx_silent=191 + :cx_silent=610 + :sourcedirs=VME_DRV/src + :sourcedirs=VME_DRV/api/include + :sourcedirs=../../../../orbsvcs + :sourcedirs=/home/ace/ACE_wrappers.latest + :sourcedirs=../../../../tao/compat + :sourcedirs=../../../.. + :libdirs=VME_DRV/vmeXportu + :libdirs=../../../../orbsvcs + :libdirs=../../../../tao + :libdirs=/home/ace/ACE_wrappers.latest/ace + :libraries=vmeXportNoLogging.a + :libraries=orbsvcs.a + :libraries=tao.a + :libraries=libACE.a + :libraries=/appl/newgreen/vxppc603/ghsbltin.o + :defines=DEBUG + :defines=VME_DRIVER +client.bld + program +server.bld + program + :defines=USE_ACE_EVENT_HANDLING diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/run_test.pl b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/run_test.pl new file mode 100755 index 00000000000..193a7c01c1d --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/run_test.pl @@ -0,0 +1,112 @@ +#$Id$ +# -*- perl -*- +eval '(exit $?0)' && eval 'exec perl -S $0 ${1+"$@"}' + & eval 'exec perl -S $0 $argv:q' + if 0; + +# Do not use environment variables here since not all platforms use ACE_ROOT +use lib "../../../../../bin"; + +require ACEutils; + +$nsport = 20000 + ACE::uniqueid (); +$server_port = 0; +$iorfile = "cubit.ior"; +$exepref = '.' . $DIR_SEPARATOR; +$svnsflags = " -s -o $iorfile"; +$clnsflags = " -s -f $iorfile"; +$clflags = " -ORBobjrefstyle url"; +$svflags = " -ORBobjrefstyle url"; +$mcast = 0; + +#make sure the file is gone, so we can wait on it. +unlink $iorfile; + +# Parse the arguments + +for ($i = 0; $i <= $#ARGV; $i++) +{ + SWITCH: + { + if ($ARGV[$i] eq "-h" || $ARGV[$i] eq "-?") + { + print "run_test [-h] [-n num] [-mcast] [-sleeptime t] [-debug] [-release] [-orblite]\n"; + print "\n"; + print "-h -- prints this information\n"; + print "-n num -- client uses <num> iterations\n"; + print "-mcast -- uses the multicast version of the nameservice\n"; + print "-sleeptime t -- run_test should sleep for <t> seconds between running\n"; + print " the server and client (default is 5 seconds)\n"; + print "-debug -- sets the debug flag for both client and server\n"; + print "-release -- runs the Release version of the test (for NT use)\n"; + print "-orblite -- Use the lite version of the orb"; + exit; + } + if ($ARGV[$i] eq "-mcast") + { + $mcast = 1; + $clnsflags = " -ORBnameserviceport $nsport"; + $svnsflags = " -ORBnameserviceport $nsport"; + last SWITCH; + } + if ($ARGV[$i] eq "-debug") + { + $clflags .= " -d"; + $svflags .= " -d"; + last SWITCH; + } + if ($ARGV[$i] eq "-release") + { + $exepref = "Release".$DIR_SEPARATOR; + last SWITCH; + } + if ($ARGV[$i] eq "-n") + { + $clflags .= " -n $ARGV[$i + 1]"; + $i++; + last SWITCH; + } + if ($ARGV[$i] eq "-sleeptime") + { + $ACE::sleeptime = $ARGV[$i + 1]; + $i++; + last SWITCH; + } + if ($ARGV[$i] eq "-orblite") + { + $clargs .= " -ORBiioplite"; + $svargs .= " -ORBiioplite"; + last SWITCH; + } + print "run_test: Unknown Option: ".$ARGV[$i]."\n"; + } +} + +$SV = Process::Create ($exepref."server".$Process::EXE_EXT, + $svflags. + $svnsflags); + +# Put in a wait between the server and client +if ($mcast == 1) +{ + sleep $ACE::sleeptime; +} +else +{ + ACE::waitforfile ($iorfile); +} + +unlink + +$status = system ($exepref."client".$Process::EXE_EXT. + $clflags. + $clnsflags. + " -x"); + +# @@ TODO change to Wait() once the -x option works. +$SV->Kill (); $SV->Wait (); + +unlink $iorfile; + +# @@ Capture any errors from the server too. +exit $status; diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.bld b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.bld new file mode 100644 index 00000000000..1eb5d4e26e9 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.bld @@ -0,0 +1,12 @@ +#!build +default: + program + :debuglevel=multi +Cubit_Client.cpp + C++ +cubitS.cpp + C++ +cubitC.cpp + C++ +server.cpp + C++ diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp new file mode 100644 index 00000000000..55a8793f0a5 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.cpp @@ -0,0 +1,45 @@ +// $Id$ + +#include "Cubit_Server.h" +#include "tao/Timeprobe.h" + +ACE_RCSID(IDL_Cubit, server, "$Id$") + +// This runs the server test. + +int +main (int argc, char *argv[]) +{ + Cubit_Server cubit_server; + + ACE_DEBUG ((LM_DEBUG, + "\n\tIDL_Cubit: server\n\n")); + TAO_TRY + { + if (cubit_server.init (argc, argv, TAO_TRY_ENV) == -1) + { + TAO_TRY_ENV.print_exception ("Initialization Exception"); + return -1; + } + else + { + cubit_server.run (TAO_TRY_ENV); + TAO_CHECK_ENV; + } + } + TAO_CATCH (CORBA::SystemException, sysex) + { + ACE_UNUSED_ARG (sysex); + TAO_TRY_ENV.print_exception ("System Exception"); + return -1; + } + TAO_CATCH (CORBA::UserException, userex) + { + ACE_UNUSED_ARG (userex); + TAO_TRY_ENV.print_exception ("User Exception"); + return -1; + } + TAO_ENDTRY; + ACE_TIMEPROBE_PRINT; + return 0; +} diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.dsp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.dsp new file mode 100644 index 00000000000..3a2e2f40148 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/server.dsp @@ -0,0 +1,224 @@ +# Microsoft Developer Studio Project File - Name="IDL_Cubit Server" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=IDL_Cubit Server - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak" CFG="IDL_Cubit Server - Win32 Release"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "IDL_Cubit Server - Win32 Release" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE "IDL_Cubit Server - Win32 Debug" (based on\
+ "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "IDL_Cubit Server - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir ".\server\Release"
+# PROP BASE Intermediate_Dir ".\server\Release"
+# PROP BASE Target_Dir ".\server"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ".\server"
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D TAO_ORBSVCS_HAS_DLL=1 /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ace.lib TAO.lib orbsvcs.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\tao\\" /libpath:"..\..\..\..\..\ace" /libpath:"..\..\..\..\orbsvcs\orbsvcs"
+
+!ELSEIF "$(CFG)" == "IDL_Cubit Server - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir ".\server\Debug"
+# PROP BASE Intermediate_Dir ".\server\Debug"
+# PROP BASE Target_Dir ".\server"
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir ".\Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ".\server"
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /YX /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D TAO_ORBSVCS_HAS_DLL=1 /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386
+# ADD LINK32 aced.lib TAOd.lib orbsvcsd.lib /nologo /subsystem:console /debug /machine:I386 /libpath:"..\..\..\..\tao" /libpath:"..\..\..\..\..\ace" /libpath:"..\..\..\..\orbsvcs\orbsvcs"
+
+!ENDIF
+
+# Begin Target
+
+# Name "IDL_Cubit Server - Win32 Release"
+# Name "IDL_Cubit Server - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;hpj;bat;for;f90"
+# Begin Source File
+
+SOURCE=.\Cubit_i.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Server.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\RTI_IO.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl;fi;fd"
+# Begin Source File
+
+SOURCE=.\Cubit_Client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Server.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\cubit.idl
+
+!IF "$(CFG)" == "IDL_Cubit Server - Win32 Release"
+
+USERDEP__CUBIT="..\..\..\..\tao_idl\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\Release\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "IDL_Cubit Server - Win32 Debug"
+
+USERDEP__CUBIT="..\..\..\..\tao_idl\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/svc.conf b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/svc.conf new file mode 100644 index 00000000000..3d0227a9192 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/svc.conf @@ -0,0 +1,8 @@ +# $Id$ +# +# Please see $TAO_ROOT/docs/Options.html for details on these options. +# + +dynamic Resource_Factory Service_Object * TAO:_make_TAO_Resource_Factory() "-ORBresources tss -ORBreactorlock null" +dynamic Client_Strategy_Factory Service_Object * TAO:_make_TAO_Default_Client_Strategy_Factory() "-ORBiiopprofilelock null" +dynamic Server_Strategy_Factory Service_Object * TAO:_make_TAO_Default_Server_Strategy_Factory() "-ORBconcurrency reactive -ORBpoalock null -ORBconnectorlock null" diff --git a/TAO/performance-tests/Cubit/TAO/IDL_Cubit/tmplinst.cpp b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/tmplinst.cpp new file mode 100644 index 00000000000..428ea1dde1a --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/IDL_Cubit/tmplinst.cpp @@ -0,0 +1,14 @@ +// +// $Id$ +// + +// The contents of this file REALLY should be generated by the IDL +// compiler, but that functionality isn't available yet. + +#include "cubitC.h" + +ACE_RCSID(IDL_Cubit, tmplinst, "$Id$") + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) +#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/MT_Cubit.dsw b/TAO/performance-tests/Cubit/TAO/MT_Cubit/MT_Cubit.dsw new file mode 100644 index 00000000000..a6f92a987cd --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/MT_Cubit.dsw @@ -0,0 +1,41 @@ +Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "MT_Cubit Client"=.\client.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "MT_Cubit Server"=.\server.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/client.dsp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/client.dsp new file mode 100644 index 00000000000..78f7770fd34 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/client.dsp @@ -0,0 +1,241 @@ +# Microsoft Developer Studio Project File - Name="MT_Cubit Client" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=MT_Cubit Client - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "client.mak" CFG="MT_Cubit Client - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "MT_Cubit Client - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "MT_Cubit Client - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "MT_Cubit Client - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "PRIORITY_INV_TEST" /FD /I /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 orbsvcs.lib ace.lib TAO.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\orbsvcs\orbsvcs" /libpath:"..\..\..\..\tao" /libpath:"..\..\..\..\..\ace"
+
+!ELSEIF "$(CFG)" == "MT_Cubit Client - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "PRIORITY_INV_TEST" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 orbsvcsd.lib aced.lib TAOd.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\..\orbsvcs\orbsvcs" /libpath:"..\..\..\..\tao" /libpath:"..\..\..\..\..\ace"
+
+!ENDIF
+
+# Begin Target
+
+# Name "MT_Cubit Client - Win32 Release"
+# Name "MT_Cubit Client - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubit_i.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Task.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Globals.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Task_Client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Timer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Util_Thread.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ".h"
+# Begin Source File
+
+SOURCE=.\client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Task_Client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Util_Thread.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\cubit.idl
+
+!IF "$(CFG)" == "MT_Cubit Client - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__CUBIT="..\..\..\..\tao_idl\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\Release\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "MT_Cubit Client - Win32 Debug"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__CUBIT="..\..\..\..\tao_idl\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/clnt.bld b/TAO/performance-tests/Cubit/TAO/MT_Cubit/clnt.bld new file mode 100644 index 00000000000..8bd06f00178 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/clnt.bld @@ -0,0 +1,10 @@ +#!build +default: + program + :debuglevel=multi +client.cpp + C++ +Task_Client.cpp + C++ +cubitC.cpp + C++ diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/default.bld b/TAO/performance-tests/Cubit/TAO/MT_Cubit/default.bld new file mode 100644 index 00000000000..e13ed31e337 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/default.bld @@ -0,0 +1,33 @@ +#!build +default: + nobuild + :c_option=slashcomment + :cx_e_option=msgnumbers + :object_dir=./.obj + :target=vxwppc + :cx_silent=21 + :cx_silent=191 + :cx_silent=610 + :sourcedirs=VME_DRV/src + :sourcedirs=VME_DRV/api/include + :sourcedirs=../../../.. + :sourcedirs=/home/ace/ACE_wrappers.vxworks + :sourcedirs=../../../../tao/compat + :sourcedirs=./client + :sourcedirs=./server + :libdirs=VME_DRV/vmeXportu + :libdirs=../../../../tao + :libdirs=/home/ace/ACE_wrappers.vxworks/ace + :libraries=vmeXport.a + :libraries=tao.a + :libraries=libACE.a + :libraries=/appl/newgreen/vxppc603/ghsbltin.o + :libraries=/appl/newgreen/vxppc603/ghsmath.o + :defines=DEBUG + :defines=FORCE_ARGS + :defines=VME_DRIVER +clnt.bld + program +svr.bld + program + :defines=USE_ACE_EVENT_HANDLING diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/server.dsp b/TAO/performance-tests/Cubit/TAO/MT_Cubit/server.dsp new file mode 100644 index 00000000000..07d51181044 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/server.dsp @@ -0,0 +1,245 @@ +# Microsoft Developer Studio Project File - Name="MT_Cubit Server" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=MT_Cubit Server - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "server.mak" CFG="MT_Cubit Server - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "MT_Cubit Server - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "MT_Cubit Server - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF "$(CFG)" == "MT_Cubit Server - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "NDEBUG" /D "WIN32" /D "_CONSOLE" /D "PRIORITY_INV_TEST" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 orbsvcs.lib ace.lib TAO.lib /nologo /subsystem:console /machine:I386 /libpath:"..\..\..\..\orbsvcs\orbsvcs" /libpath:"..\..\..\..\tao" /libpath:"..\..\..\..\..\ace"
+
+!ELSEIF "$(CFG)" == "MT_Cubit Server - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir ""
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\..\\" /I "..\..\..\..\..\\" /I "..\..\..\..\orbsvcs" /D "_DEBUG" /D "WIN32" /D "_CONSOLE" /D "PRIORITY_INV_TEST" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 orbsvcsd.lib aced.lib TAOd.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\..\..\..\orbsvcs\orbsvcs" /libpath:"..\..\..\..\tao" /libpath:"..\..\..\..\..\ace"
+
+!ENDIF
+
+# Begin Target
+
+# Name "MT_Cubit Server - Win32 Release"
+# Name "MT_Cubit Server - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter ".cpp"
+# Begin Source File
+
+SOURCE=.\cubit_i.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Cubit_Task.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Globals.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\server.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Task_Client.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Timer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\Util_Thread.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter ".h"
+# Begin Source File
+
+SOURCE=.\cubit_i.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitC.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\cubitS.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\server.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Task_Client.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\Util_Thread.h
+# End Source File
+# End Group
+# Begin Group "IDL Files"
+
+# PROP Default_Filter ".idl"
+# Begin Source File
+
+SOURCE=.\cubit.idl
+
+!IF "$(CFG)" == "MT_Cubit Server - Win32 Release"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__CUBIT="..\..\..\..\tao_idl\Release\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\Release\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ELSEIF "$(CFG)" == "MT_Cubit Server - Win32 Debug"
+
+# PROP Ignore_Default_Tool 1
+USERDEP__CUBIT="..\..\..\..\tao_idl\tao_idl.exe"
+# Begin Custom Build - Invoking TAO_IDL Compiler
+InputPath=.\cubit.idl
+InputName=cubit
+
+BuildCmds= \
+ ..\..\..\..\tao_idl\tao_idl $(InputName).idl
+
+"$(InputName)C.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)C.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.h" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.i" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+
+"$(InputName)S_T.cpp" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)"
+ $(BuildCmds)
+# End Custom Build
+
+!ENDIF
+
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/TAO/performance-tests/Cubit/TAO/MT_Cubit/svr.bld b/TAO/performance-tests/Cubit/TAO/MT_Cubit/svr.bld new file mode 100644 index 00000000000..94b68d515c4 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/MT_Cubit/svr.bld @@ -0,0 +1,12 @@ +#!build +default: + program + :debuglevel=multi +cubit_i.cpp + C++ +cubitS.cpp + C++ +svr.cpp + C++ +cubitC.cpp + C++ diff --git a/TAO/performance-tests/Cubit/TAO/Makefile b/TAO/performance-tests/Cubit/TAO/Makefile new file mode 100644 index 00000000000..f5c52349620 --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/Makefile @@ -0,0 +1,25 @@ +#---------------------------------------------------------------------------- +# $Id$ +# +# Makefile for the TAO Cubit tests +#---------------------------------------------------------------------------- + +#---------------------------------------------------------------------------- +# Local macros +#---------------------------------------------------------------------------- + +# Currently, IDL_Cubit *must* come before the IDL_Cubit tests. +DIRS = IDL_Cubit \ + MT_Cubit \ + DII_Cubit \ + +#---------------------------------------------------------------------------- +# Include macros and targets +#---------------------------------------------------------------------------- + +include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU +include $(ACE_ROOT)/include/makeinclude/macros.GNU +include $(ACE_ROOT)/include/makeinclude/rules.common.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nested.GNU +include $(ACE_ROOT)/include/makeinclude/rules.nolocal.GNU + diff --git a/TAO/performance-tests/Cubit/TAO/README b/TAO/performance-tests/Cubit/TAO/README new file mode 100644 index 00000000000..61da08408de --- /dev/null +++ b/TAO/performance-tests/Cubit/TAO/README @@ -0,0 +1,20 @@ +There are three versions of the Cubit example. Individual README files +in the respective directories explain these versions in further +detail. + + . IDL_Cubit + + Cubit example with tao_idl compiler generated stubs + and skeletons + + . MT_Cubit + + Multithreaded real-time Cubit example. + + . DII_Cubit + + Cubit example with hand-generated stubs. When + TAO supports the DII interface this will + illustrate how it works. + + diff --git a/TAO/performance-tests/Cubit/VisiBroker/base_server/Makefile b/TAO/performance-tests/Cubit/VisiBroker/base_server/Makefile new file mode 100644 index 00000000000..4b40c012e55 --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/base_server/Makefile @@ -0,0 +1,21 @@ +# $Id$ + +include stdmk + +EXE = server + +all: $(EXE) + +clean: + -rm -f core *.o cubitC.* cubitS.* $(EXE) + -rm -rf Templates.DB + +cubitS.cpp: cubit.idl + $(ORBCC) cubit.idl + +cubitC.cpp: cubit.idl + $(ORBCC) cubit.idl + +server: cubitS.o cubitC.o server.o Profile_Timer.o cubit_impl.o + $(CC) -o server cubitS.o cubitC.o cubit_impl.o server.o Profile_Timer.o \ + $(LIBPATH) $(LIBORB) $(STDCC_LIBS) diff --git a/TAO/performance-tests/Cubit/VisiBroker/base_server/Profile_Timer.cpp b/TAO/performance-tests/Cubit/VisiBroker/base_server/Profile_Timer.cpp new file mode 100644 index 00000000000..42dce7eb80a --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/base_server/Profile_Timer.cpp @@ -0,0 +1,131 @@ +// $Id$ + +#include "Profile_Timer.h" + +ACE_RCSID(base_server, Profile_Timer, "$Id$") + +/* Initialize interval timer. */ + +Profile_Timer::Profile_Timer (void) +{ + char buf[20]; + ::sprintf(buf, "/proc/%d", ::getpid ()); + + ::memset (&this->end_usage_, 0, sizeof this->end_usage_); + ::memset (&this->begin_usage_, 0, sizeof this->begin_usage_); + ::memset (&this->last_usage_, 0, sizeof this->last_usage_); + if ((this->proc_fd_ = ::open (buf, O_RDONLY, 0)) == -1) + ::perror (buf); +} + +/* Terminate the interval timer. */ +Profile_Timer::~Profile_Timer (void) +{ + if (::close (this->proc_fd_) == -1) + ::perror ("Profile_Timer::~Profile_Timer"); +} + +/* Return the resource utilization. */ + +void +Profile_Timer::get_rusage (prusage_t &rusage) +{ + rusage = this->end_usage_; +} + +/* Compute the amount of resource utilization since the start time. */ + +void +Profile_Timer::elapsed_rusage (prusage_t &rusage) +{ + rusage.pr_lwpid = this->end_usage_.pr_lwpid - this->last_usage_.pr_lwpid; + rusage.pr_count = this->end_usage_.pr_count - this->last_usage_.pr_count; + rusage.pr_minf = this->end_usage_.pr_minf - this->last_usage_.pr_minf; + rusage.pr_majf = this->end_usage_.pr_majf - this->last_usage_.pr_majf; + rusage.pr_inblk = this->end_usage_.pr_inblk - this->last_usage_.pr_inblk; + rusage.pr_oublk = this->end_usage_.pr_oublk - this->last_usage_.pr_oublk; + rusage.pr_msnd = this->end_usage_.pr_msnd - this->last_usage_.pr_msnd; + rusage.pr_mrcv = this->end_usage_.pr_mrcv - this->last_usage_.pr_mrcv; + rusage.pr_sigs = this->end_usage_.pr_sigs - this->last_usage_.pr_sigs; + this->subtract (rusage.pr_wtime, this->end_usage_.pr_wtime, this->last_usage_.pr_wtime); + this->subtract (rusage.pr_ltime, this->end_usage_.pr_ltime, this->last_usage_.pr_ltime); + this->subtract (rusage.pr_slptime, this->end_usage_.pr_slptime, this->last_usage_.pr_slptime); + rusage.pr_vctx = this->end_usage_.pr_vctx - this->last_usage_.pr_vctx; + rusage.pr_ictx = this->end_usage_.pr_ictx - this->last_usage_.pr_ictx; + rusage.pr_sysc = this->end_usage_.pr_sysc - this->last_usage_.pr_sysc; + rusage.pr_ioch = this->end_usage_.pr_ioch - this->last_usage_.pr_ioch; +} + +/* Compute the elapsed time. */ + +void +Profile_Timer::compute_times (Elapsed_Time &et, prusage_t &end, prusage_t &begin) +{ + timespec_t td; + + this->subtract (td, end.pr_tstamp, begin.pr_tstamp); + et.real_time = td.tv_sec + ((double) td.tv_nsec) / (1000 * 1000 * 1000); + this->subtract (td, end.pr_utime, begin.pr_utime); + et.user_time = td.tv_sec + ((double) td.tv_nsec) / (1000 * 1000 * 1000); + this->subtract (td, end.pr_stime, begin.pr_stime); + et.system_time = td.tv_sec + ((double) td.tv_nsec) / (1000 * 1000 * 1000); +} + +/* Compute the amount of time that has elapsed between start and stop. */ + +int +Profile_Timer::elapsed_time (Elapsed_Time &et) +{ + this->compute_times (et, this->end_usage_, this->begin_usage_); + return 0; +} + +/* Determine the difference between T1 and T2. */ + +void +Profile_Timer::subtract (timespec_t &tdiff, timespec_t &t1, timespec_t &t0) +{ + tdiff.tv_sec = t1.tv_sec - t0.tv_sec; + tdiff.tv_nsec = t1.tv_nsec - t0.tv_nsec; + + /* Normalize the time. */ + + while (tdiff.tv_nsec < 0) + { + tdiff.tv_sec--; + tdiff.tv_nsec += (1000 * 1000 * 1000); + } +} + +#if defined (DEBUG) +#include <stdlib.h> +extern "C" int gettimeofday (timeval *tp); + +const int DEFAULT_ITERATIONS = 1000000; + +int +main (int argc, char *argv[]) +{ + Profile_Timer timer; + int iterations = argc > 1 ? atoi (argv[1]) : DEFAULT_ITERATIONS; + timeval tv; + + timer.start (); + + for (int i = 0; i < iterations; i++) + gettimeofday (&tv); + + timer.stop (); + + Profile_Timer::Elapsed_Time et; + + timer.elapsed_time (et); + + printf ("iterations = %d\n", iterations); + printf ("real time = %f secs, user time = %f secs, system time = %f secs\n", + et.real_time, et.user_time, et.system_time); + + printf ("time per call = %f usecs\n", (et.real_time / double (iterations)) * 1000000); + return 0; +} +#endif /* DEBUG */ diff --git a/TAO/performance-tests/Cubit/VisiBroker/base_server/Profile_Timer.h b/TAO/performance-tests/Cubit/VisiBroker/base_server/Profile_Timer.h new file mode 100644 index 00000000000..4198fba9a10 --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/base_server/Profile_Timer.h @@ -0,0 +1,62 @@ +/* -*- C++ -*- */ +// $Id$ + +/* An interval timer class using C++. */ + +#if !defined (ACE_PROFILE_TIMER_H) +#define ACE_PROFILE_TIMER_H + +#include <sys/types.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/procfs.h> +#include <stdio.h> +#include <memory.h> + +class Profile_Timer +{ +public: + struct Elapsed_Time + { + double real_time; + double user_time; + double system_time; + }; + + Profile_Timer (void); + ~Profile_Timer (void); + int start (void); + int stop (void); + int elapsed_time (Elapsed_Time &et); + void elapsed_rusage (prusage_t &rusage); + void get_rusage (prusage_t &rusage); + +private: + void subtract (timespec_t &tdiff, timespec_t &t0, timespec_t &t1); + void compute_times (Elapsed_Time &et, prusage_t &, prusage_t &); + + prusage_t begin_usage_; + prusage_t end_usage_; + prusage_t last_usage_; + int proc_fd_; +}; + +/* Start timing */ + +inline int +Profile_Timer::start (void) +{ + return ::ioctl (this->proc_fd_, PIOCUSAGE, &this->begin_usage_); +} + +/* Stop timing */ + +inline int +Profile_Timer::stop (void) +{ + this->last_usage_ = this->end_usage_; + return ::ioctl (this->proc_fd_, PIOCUSAGE, &this->end_usage_); +} + +#endif /* ACE_PROFILE_TIMER_H */ + diff --git a/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit.idl b/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit.idl new file mode 100644 index 00000000000..7eedbe786ab --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit.idl @@ -0,0 +1,42 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. +// +//#pragma prefix "Eng.SUN.COM" +//#pragma version Cubit 1.1 + +interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); +}; diff --git a/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit_impl.cpp b/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit_impl.cpp new file mode 100644 index 00000000000..123406d993c --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit_impl.cpp @@ -0,0 +1,50 @@ +// $Id$ + +#include "cubit_impl.h" + +ACE_RCSID(base_server, cubit_impl, "$Id$") + +CORBA::Octet Cubit_Impl:: cube_octet (CORBA::Octet o) { + return (CORBA::Octet) (o * o * o); +} + +CORBA::Short Cubit_Impl:: cube_short (CORBA::Short s) { + return (CORBA::Short) (s * s * s); +} + +CORBA::Long Cubit_Impl:: cube_long (CORBA::Long l) { + return (CORBA::Long) (l * l * l); +} + +Cubit::Many Cubit_Impl:: cube_struct (const Cubit::Many& values) { + Cubit::Many out_values; + out_values.o = values.o * values.o * values.o; + out_values.s = values.s * values.s * values.s; + out_values.l = values.l * values.l * values.l; + return out_values; +} + +Cubit::oneof Cubit_Impl:: cube_union (const Cubit::oneof& values) { + Cubit::oneof out_values; + switch (values._d ()) { + case Cubit::e_0th: + out_values.o (values.o () * values.o () * values.o ()); + break; + case Cubit::e_1st: + out_values.s (values.s () * values.s () * values.s ()); + break; + case Cubit::e_2nd: + out_values.l (values.l () * values.l () * values.l ()); + break; + case Cubit::e_3rd: + default: + out_values.cm ().o = values.cm ().o * values.cm ().o * values.cm ().o ; + out_values.cm ().s = values.cm ().s * values.cm ().s * values.cm ().s ; + out_values.cm ().l = values.cm ().l * values.cm ().l * values.cm ().l ; + break; + } + return out_values; +} + +void Cubit_Impl:: please_exit () + {} diff --git a/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit_impl.h b/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit_impl.h new file mode 100644 index 00000000000..f1f5e3fa3ea --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/base_server/cubit_impl.h @@ -0,0 +1,35 @@ +// $Id$ + + +#ifndef cubit_ih +#define cubit_ih + +#include "cubitS.h" + + +#ifdef Cubit_USE_BOA +class Cubit_Impl : public virtual _sk_Cubit { +#else +class Cubit_Impl { +#endif /* Cubit_USE_BOA */ + +public: + +#ifdef Cubit_USE_BOA + Cubit_Impl (const char *obj_name = NULL) : + _sk_Cubit(obj_name) + {} +#else + Cubit_Impl (const char *obj_name = NULL) + {} +#endif /* Cubit_USE_BOA */ + + virtual CORBA::Octet cube_octet(CORBA::Octet o); + virtual CORBA::Short cube_short(CORBA::Short s); + virtual CORBA::Long cube_long(CORBA::Long l); + virtual Cubit::Many cube_struct(const Cubit::Many& values); + virtual Cubit::oneof cube_union(const Cubit::oneof& values); + virtual void please_exit(); +}; + +#endif diff --git a/TAO/performance-tests/Cubit/VisiBroker/base_server/server.cpp b/TAO/performance-tests/Cubit/VisiBroker/base_server/server.cpp new file mode 100644 index 00000000000..5a2bccfa186 --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/base_server/server.cpp @@ -0,0 +1,53 @@ +// $Id$ + +// ************************************************************************** +// +// NAME : tpr_server.cpp +// DESCRIPTION: +// +// Server mainline +// +// **************************************************************************** +#include "cubit_impl.h" // server header file + +ACE_RCSID(base_server, server, "$Id$") + +int +main (int argc, char** argv) +{ + + CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); + CORBA::BOA_var boa = orb->BOA_init(argc, argv); + +#ifdef Cubit_USE_BOA + Cubit_Impl cb("Cubit"); + cout << "Using BOA approach" << endl; +#else + Cubit_Impl tied("Cubit"); + _tie_Cubit<Cubit_Impl> cb(tied, "Cubit"); + + cout << "Using TIE approach" << endl; +#endif /* Cubit_USE_BOA */ + + // + // Go get some work to do.... + // + try { + + boa->obj_is_ready(&cb); + + boa->impl_is_ready(); + + } catch (const CORBA::Exception &excep) { + cerr << "Server error: " << excep << endl; + return -1; + } catch (...) { + cerr << "Unknown exception" << endl; + return -1; + } + + cout << "Cubit server is exiting." << endl; + + + return 0; +} diff --git a/TAO/performance-tests/Cubit/VisiBroker/base_server/stdmk b/TAO/performance-tests/Cubit/VisiBroker/base_server/stdmk new file mode 100644 index 00000000000..df4125a38d8 --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/base_server/stdmk @@ -0,0 +1,36 @@ +CC = CC +DEBUG = + +ORBELINEDIR = /project/waltz/Orbeline2.0 + +ORBCC = $(ORBELINEDIR)/bin/orbeline -v C -m S -c cpp -h h + +CCINCLUDES = -I. -I$(ORBELINEDIR)/include -I$(STL_DIR) -I$(ACE_DIR) + +CCFLAGS = -g $(CCINCLUDES) $(DEBUG) -DCubit_USE_BOA + +LIBPATH = -L$(ORBELINEDIR)/lib -L$(ACE_DIR)/ace + +STDCC_LIBS = -lsocket -lnsl -ldl -mt + +LIBORB = -lorb + +LIBACE = -lACE + +.SUFFIXES: .C .o .h .hh .cc .cpp + +.C.o: + $(CC) $(CCFLAGS) -c -o $@ $< + +.cc.o: + $(CC) $(CCFLAGS) -c -o $@ $< +.cpp.o: + $(CC) $(CCFLAGS) -c -o $@ $< + +.C.cpp: + $(CC) -E $(CCFLAGS) $< > $@ + +.cc.cpp: + $(CC) -E $(CCFLAGS) $< > $@ + + diff --git a/TAO/performance-tests/Cubit/VisiBroker/client/Makefile b/TAO/performance-tests/Cubit/VisiBroker/client/Makefile new file mode 100644 index 00000000000..ac2d882a3ce --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/client/Makefile @@ -0,0 +1,21 @@ +# $Id$ + +include stdmk + +EXE = client + +all: $(EXE) + +clean: + -rm -f core *.o cubitC.* cubitS.* $(EXE) + -rm -rf Templates.DB + +cubitS.cpp: cubit.idl + $(ORBCC) cubit.idl + +cubitC.cpp: cubit.idl + $(ORBCC) cubit.idl + +client: cubitC.o Profile_Timer.o client.o + $(CC) -o client cubitC.o Profile_Timer.o client.o \ + $(LIBPATH) $(LIBORB) $(STDCC_LIBS) diff --git a/TAO/performance-tests/Cubit/VisiBroker/client/Profile_Timer.cpp b/TAO/performance-tests/Cubit/VisiBroker/client/Profile_Timer.cpp new file mode 100644 index 00000000000..2d1f74b2e69 --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/client/Profile_Timer.cpp @@ -0,0 +1,131 @@ +// $Id$ + +#include "Profile_Timer.h" + +ACE_RCSID(client, Profile_Timer, "$Id$") + +/* Initialize interval timer. */ + +Profile_Timer::Profile_Timer (void) +{ + char buf[20]; + ::sprintf(buf, "/proc/%d", ::getpid ()); + + ::memset (&this->end_usage_, 0, sizeof this->end_usage_); + ::memset (&this->begin_usage_, 0, sizeof this->begin_usage_); + ::memset (&this->last_usage_, 0, sizeof this->last_usage_); + if ((this->proc_fd_ = ::open (buf, O_RDONLY, 0)) == -1) + ::perror (buf); +} + +/* Terminate the interval timer. */ +Profile_Timer::~Profile_Timer (void) +{ + if (::close (this->proc_fd_) == -1) + ::perror ("Profile_Timer::~Profile_Timer"); +} + +/* Return the resource utilization. */ + +void +Profile_Timer::get_rusage (prusage_t &rusage) +{ + rusage = this->end_usage_; +} + +/* Compute the amount of resource utilization since the start time. */ + +void +Profile_Timer::elapsed_rusage (prusage_t &rusage) +{ + rusage.pr_lwpid = this->end_usage_.pr_lwpid - this->last_usage_.pr_lwpid; + rusage.pr_count = this->end_usage_.pr_count - this->last_usage_.pr_count; + rusage.pr_minf = this->end_usage_.pr_minf - this->last_usage_.pr_minf; + rusage.pr_majf = this->end_usage_.pr_majf - this->last_usage_.pr_majf; + rusage.pr_inblk = this->end_usage_.pr_inblk - this->last_usage_.pr_inblk; + rusage.pr_oublk = this->end_usage_.pr_oublk - this->last_usage_.pr_oublk; + rusage.pr_msnd = this->end_usage_.pr_msnd - this->last_usage_.pr_msnd; + rusage.pr_mrcv = this->end_usage_.pr_mrcv - this->last_usage_.pr_mrcv; + rusage.pr_sigs = this->end_usage_.pr_sigs - this->last_usage_.pr_sigs; + this->subtract (rusage.pr_wtime, this->end_usage_.pr_wtime, this->last_usage_.pr_wtime); + this->subtract (rusage.pr_ltime, this->end_usage_.pr_ltime, this->last_usage_.pr_ltime); + this->subtract (rusage.pr_slptime, this->end_usage_.pr_slptime, this->last_usage_.pr_slptime); + rusage.pr_vctx = this->end_usage_.pr_vctx - this->last_usage_.pr_vctx; + rusage.pr_ictx = this->end_usage_.pr_ictx - this->last_usage_.pr_ictx; + rusage.pr_sysc = this->end_usage_.pr_sysc - this->last_usage_.pr_sysc; + rusage.pr_ioch = this->end_usage_.pr_ioch - this->last_usage_.pr_ioch; +} + +/* Compute the elapsed time. */ + +void +Profile_Timer::compute_times (Elapsed_Time &et, prusage_t &end, prusage_t &begin) +{ + timespec_t td; + + this->subtract (td, end.pr_tstamp, begin.pr_tstamp); + et.real_time = td.tv_sec + ((double) td.tv_nsec) / (1000 * 1000 * 1000); + this->subtract (td, end.pr_utime, begin.pr_utime); + et.user_time = td.tv_sec + ((double) td.tv_nsec) / (1000 * 1000 * 1000); + this->subtract (td, end.pr_stime, begin.pr_stime); + et.system_time = td.tv_sec + ((double) td.tv_nsec) / (1000 * 1000 * 1000); +} + +/* Compute the amount of time that has elapsed between start and stop. */ + +int +Profile_Timer::elapsed_time (Elapsed_Time &et) +{ + this->compute_times (et, this->end_usage_, this->begin_usage_); + return 0; +} + +/* Determine the difference between T1 and T2. */ + +void +Profile_Timer::subtract (timespec_t &tdiff, timespec_t &t1, timespec_t &t0) +{ + tdiff.tv_sec = t1.tv_sec - t0.tv_sec; + tdiff.tv_nsec = t1.tv_nsec - t0.tv_nsec; + + /* Normalize the time. */ + + while (tdiff.tv_nsec < 0) + { + tdiff.tv_sec--; + tdiff.tv_nsec += (1000 * 1000 * 1000); + } +} + +#if defined (DEBUG) +#include <stdlib.h> +extern "C" int gettimeofday (timeval *tp); + +const int DEFAULT_ITERATIONS = 1000000; + +int +main (int argc, char *argv[]) +{ + Profile_Timer timer; + int iterations = argc > 1 ? atoi (argv[1]) : DEFAULT_ITERATIONS; + timeval tv; + + timer.start (); + + for (int i = 0; i < iterations; i++) + gettimeofday (&tv); + + timer.stop (); + + Profile_Timer::Elapsed_Time et; + + timer.elapsed_time (et); + + printf ("iterations = %d\n", iterations); + printf ("real time = %f secs, user time = %f secs, system time = %f secs\n", + et.real_time, et.user_time, et.system_time); + + printf ("time per call = %f usecs\n", (et.real_time / double (iterations)) * 1000000); + return 0; +} +#endif /* DEBUG */ diff --git a/TAO/performance-tests/Cubit/VisiBroker/client/Profile_Timer.h b/TAO/performance-tests/Cubit/VisiBroker/client/Profile_Timer.h new file mode 100644 index 00000000000..4198fba9a10 --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/client/Profile_Timer.h @@ -0,0 +1,62 @@ +/* -*- C++ -*- */ +// $Id$ + +/* An interval timer class using C++. */ + +#if !defined (ACE_PROFILE_TIMER_H) +#define ACE_PROFILE_TIMER_H + +#include <sys/types.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/procfs.h> +#include <stdio.h> +#include <memory.h> + +class Profile_Timer +{ +public: + struct Elapsed_Time + { + double real_time; + double user_time; + double system_time; + }; + + Profile_Timer (void); + ~Profile_Timer (void); + int start (void); + int stop (void); + int elapsed_time (Elapsed_Time &et); + void elapsed_rusage (prusage_t &rusage); + void get_rusage (prusage_t &rusage); + +private: + void subtract (timespec_t &tdiff, timespec_t &t0, timespec_t &t1); + void compute_times (Elapsed_Time &et, prusage_t &, prusage_t &); + + prusage_t begin_usage_; + prusage_t end_usage_; + prusage_t last_usage_; + int proc_fd_; +}; + +/* Start timing */ + +inline int +Profile_Timer::start (void) +{ + return ::ioctl (this->proc_fd_, PIOCUSAGE, &this->begin_usage_); +} + +/* Stop timing */ + +inline int +Profile_Timer::stop (void) +{ + this->last_usage_ = this->end_usage_; + return ::ioctl (this->proc_fd_, PIOCUSAGE, &this->end_usage_); +} + +#endif /* ACE_PROFILE_TIMER_H */ + diff --git a/TAO/performance-tests/Cubit/VisiBroker/client/client.cpp b/TAO/performance-tests/Cubit/VisiBroker/client/client.cpp new file mode 100644 index 00000000000..1d8c9115bea --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/client/client.cpp @@ -0,0 +1,320 @@ +// $Id$ + +//************************************************************************** +// +// NAME : client.C +// DESCRIPTION: +// +// Client for the Cubit example +// +//**************************************************************************** + +#include <iostream.h> +#include <stdio.h> +#include <string.h> +#include <time.h> +#include <stdlib.h> +#include "cubitC.h" +#include "Profile_Timer.h" + +ACE_RCSID(client, client, "$Id$") + +int LOOP_COUNT; +char SERVER_HOST [1024]; + +inline int func (unsigned i) { return i - 117; } +void run_tests (Cubit_var, int); + +// = TITLE +// Parses the command line arguments and returns an error status +// +// = DESCRIPTION +// This method parses the command line arguments +int parse_args(int argc, char *argv[]) +{ + if (argc != 3) { + cerr << "Format: client <machine name> <loop count>" << endl; + return -1; + } + + strcpy(SERVER_HOST, argv[1]); + + LOOP_COUNT = atoi(argv[2]); + + return 0; // Indicates successful parsing of command line +} + + +// +// Mainline +// +int +main (int argc, char *argv[]) +{ + if (parse_args (argc, argv) != 0) + return -1; + + Cubit_var cb; + // cout << "attempting to contact server at host " << SERVER_HOST << '\n' ; + + // + // Initialise client's binding to an + // arbitrary cubit server (at some host) + // + try { + cb = Cubit::_bind ("Cubit", SERVER_HOST); + + } catch (const CORBA::Exception & sysEx) { + cerr << "Binding failed: " << endl; + cerr << sysEx; + } catch (...) { + cerr << "Unexpected exception" << endl; + } + + run_tests (cb, LOOP_COUNT); + return 0; +} + + +void +run_tests (Cubit_var cb, int loop_count) +{ + // + // Make the calls in a loop. + // + unsigned i; + unsigned call_count, error_count; + + Profile_Timer pt; + Elapsed_Time et; + + // + // Cube an octet. + // + + call_count = 0; + error_count = 0; + pt.start(); + + for (i = 0; i < loop_count; i++) + { + + call_count++; + + CORBA::Octet arg_octet = func (i), ret_octet; + + try { + ret_octet = cb->cube_octet (arg_octet); + + } catch (const CORBA::Exception &sysEx) { + cerr << "Call failed: " << endl; + cerr << sysEx; + error_count++; + } catch (...) { + cerr << "Unexpected exception" << endl; + error_count++; + } + + arg_octet = arg_octet * arg_octet * arg_octet; + if (arg_octet != ret_octet) { + printf ("** cube_octet(%d) (--> %d)\n", arg_octet , ret_octet); + error_count++; + } + } + + pt.stop(); + pt.elapsed_time(et); + + if (call_count > 0) + { + if (error_count == 0) + { + unsigned long us = et.real_time * 1000 * 1000; + + us /= call_count; + + if (us > 0) + printf ("cube octet average call ACE_OS::time\t= %ld.%.03ldms, \t" + "%ld calls/second\n", + us / 1000, us % 1000, + 1000000L / us); + } + + printf ("%d calls, %d errors\n", call_count, error_count); + } + + + // + // Cube a short. + // + call_count = 0; + error_count = 0; + pt.start(); + + for (i = 0; i < loop_count; i++) + { + + call_count++; + + CORBA::Short arg_short = func (i), ret_short; + + try { + ret_short = cb->cube_short (arg_short); + + } catch (const CORBA::Exception &sysEx) { + cerr << "Call failed: " << endl; + cerr << sysEx; + error_count++; + } catch (...) { + cerr << "Unexpected exception" << endl; + error_count++; + } + + arg_short = arg_short * arg_short * arg_short; + if (arg_short != ret_short) { + printf ("** cube_short(%d) (--> %d)\n", arg_short , ret_short); + error_count++; + } + } + + pt.stop(); + pt.elapsed_time(et); + + if (call_count > 0) + { + if (error_count == 0) + { + unsigned long us = et.real_time * 1000 * 1000; + + us /= call_count; + + if (us > 0) + printf ("cube short average call ACE_OS::time\t= %ld.%.03ldms, \t" + "%ld calls/second\n", + us / 1000, us % 1000, + 1000000L / us); + } + + printf ("%d calls, %d errors\n", call_count, error_count); + } + + // + // Cube a long. + // + + call_count = 0; + error_count = 0; + pt.start(); + + for (i = 0; i < loop_count; i++) + { + + call_count++; + + CORBA::Long arg_long = func (i), ret_long; + + try { + ret_long = cb->cube_long (arg_long); + } catch (const CORBA::Exception &sysEx) { + cerr << "Call failed: " << endl; + cerr << sysEx; + error_count++; + } catch (...) { + cerr << "Unexpected exception" << endl; + error_count++; + } + + arg_long = arg_long * arg_long * arg_long; + if (arg_long != ret_long) { + printf ("** cube_long(%d) (--> %d)\n", arg_long , ret_long); + error_count++; + } + } + + pt.stop(); + pt.elapsed_time(et); + + if (call_count > 0) + { + if (error_count == 0) + { + unsigned long us = et.real_time * 1000 * 1000; + + us /= call_count; + + if (us > 0) + printf ("cube long average call ACE_OS::time\t= %ld.%.03ldms, \t" + "%ld calls/second\n", + us / 1000, us % 1000, + 1000000L / us); + } + + printf ("%d calls, %d errors\n", call_count, error_count); + } + + + // + // Cube a "struct" ... + // + Cubit::Many arg_struct, ret_struct; + + call_count = 0; + error_count = 0; + pt.start(); + + for (i = 0; i < loop_count; i++) + { + + call_count++; + + arg_struct.l = func (i); + arg_struct.s = func (i); + arg_struct.o = func (i); + + try { + ret_struct = cb->cube_struct (arg_struct); + + } catch (const CORBA::Exception &sysEx) { + cerr << "Call failed: " << endl; + cerr << sysEx; + error_count++; + } catch (...) { + cerr << "Unexpected exception" << endl; + error_count++; + } + + + arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l ; + arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s ; + arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o ; + + if (arg_struct.l != ret_struct.l + || arg_struct.s != ret_struct.s + || arg_struct.o != ret_struct.o ) + { + cerr << "** cube_struct ERROR\n"; + error_count++; + } + } + + pt.stop(); + pt.elapsed_time(et); + + if (call_count > 0) + { + if (error_count == 0) + { + unsigned long us = et.real_time * 1000 * 1000; + + us /= call_count; + + if (us > 0) + printf ("cube struuct average call ACE_OS::time\t= %ld.%.03ldms, \t" + "%ld calls/second\n", + us / 1000, us % 1000, + 1000000L / us); + } + + printf ("%d calls, %d errors\n", call_count, error_count); + } +} diff --git a/TAO/performance-tests/Cubit/VisiBroker/client/cubit.idl b/TAO/performance-tests/Cubit/VisiBroker/client/cubit.idl new file mode 100644 index 00000000000..7eedbe786ab --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/client/cubit.idl @@ -0,0 +1,42 @@ +// $Id$ + +// @(#)cubit.idl 1.1 95/09/10 +// Copyright 1994-1995 by Sun Microsystems, Inc. +// +//#pragma prefix "Eng.SUN.COM" +//#pragma version Cubit 1.1 + +interface Cubit { + octet cube_octet (in octet o); + short cube_short (in short s); + long cube_long (in long l); + + struct Many { + octet o; // + 3 bytes padding (normally) ... + long l; + short s; // + 2 bytes padding (normally) ... + }; + + Many cube_struct (in Many values); + + enum discrim {e_0th, e_1st, e_2nd, e_3rd, e_4th, e_5th}; + + union oneof + switch (discrim) { + // this is an easy union to interpret; no padding + // is needed between discriminant and value. + case e_0th: + octet o; + case e_1st: + short s; + case e_2nd: + long l; + case e_3rd: + default: + Many cm; + }; + + oneof cube_union (in oneof values); + + oneway void please_exit (); +}; diff --git a/TAO/performance-tests/Cubit/VisiBroker/client/stdmk b/TAO/performance-tests/Cubit/VisiBroker/client/stdmk new file mode 100644 index 00000000000..df4125a38d8 --- /dev/null +++ b/TAO/performance-tests/Cubit/VisiBroker/client/stdmk @@ -0,0 +1,36 @@ +CC = CC +DEBUG = + +ORBELINEDIR = /project/waltz/Orbeline2.0 + +ORBCC = $(ORBELINEDIR)/bin/orbeline -v C -m S -c cpp -h h + +CCINCLUDES = -I. -I$(ORBELINEDIR)/include -I$(STL_DIR) -I$(ACE_DIR) + +CCFLAGS = -g $(CCINCLUDES) $(DEBUG) -DCubit_USE_BOA + +LIBPATH = -L$(ORBELINEDIR)/lib -L$(ACE_DIR)/ace + +STDCC_LIBS = -lsocket -lnsl -ldl -mt + +LIBORB = -lorb + +LIBACE = -lACE + +.SUFFIXES: .C .o .h .hh .cc .cpp + +.C.o: + $(CC) $(CCFLAGS) -c -o $@ $< + +.cc.o: + $(CC) $(CCFLAGS) -c -o $@ $< +.cpp.o: + $(CC) $(CCFLAGS) -c -o $@ $< + +.C.cpp: + $(CC) -E $(CCFLAGS) $< > $@ + +.cc.cpp: + $(CC) -E $(CCFLAGS) $< > $@ + + |