summaryrefslogtreecommitdiff
path: root/TAO/performance-tests/Demux/server.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'TAO/performance-tests/Demux/server.cpp')
-rw-r--r--TAO/performance-tests/Demux/server.cpp317
1 files changed, 317 insertions, 0 deletions
diff --git a/TAO/performance-tests/Demux/server.cpp b/TAO/performance-tests/Demux/server.cpp
new file mode 100644
index 00000000000..d4c10e35a5d
--- /dev/null
+++ b/TAO/performance-tests/Demux/server.cpp
@@ -0,0 +1,317 @@
+// $Id$
+
+#include "tao_demux_i.h"
+
+#ifdef USE_QUANTIFY
+#include <quantify.h>
+#endif
+
+#include <iostream.h>
+#include <fstream.h>
+
+#include "ace/SString.h"
+
+ACE_RCSID(Demux_Test, server, "$Id$")
+
+void print_exception (const CORBA_Exception *x,
+ const char *info,
+ FILE *stream
+ );
+
+#if !defined (__cplusplus)
+typedef void (*SIG_TYP)();
+#endif
+
+#ifdef SVR4
+void
+sigpipe (int foo)
+#else
+ void
+sigpipe ()
+#endif
+{
+}
+
+//****************** perf hash for obj lookup *************
+// for perfect hash
+struct object_db
+{
+ char *name; // name of method
+ CORBA_Object_ptr obj; //fn pointer to obj impl
+};
+
+// include the perfect hash code for objects
+#include "gperf_object.i"
+
+// Perfect hash table class
+class TAO_Perfect_Hash_ObjTable: public TAO_Object_Table
+{
+public:
+ TAO_Perfect_Hash_ObjTable (Object_Hash *oh);
+
+ ~TAO_Perfect_Hash_ObjTable (void);
+
+ virtual int bind (const CORBA_OctetSeq &key,
+ CORBA_Object_ptr obj);
+ // Registers a CORBA_Object into the object table and associates the
+ // key with it. Returns -1 on failure, 0 on success, 1 on
+ // duplicate.
+
+ virtual int find (const CORBA_OctetSeq &key,
+ CORBA_Object_ptr &obj);
+ // Looks up an object in the object table using <{key}>. Returns
+ // non-negative integer on success, or -1 on failure.
+
+private:
+ Object_Hash *hash_;
+};
+
+TAO_Perfect_Hash_ObjTable::TAO_Perfect_Hash_ObjTable (Object_Hash *oh)
+ : hash_ (oh)
+{
+}
+
+TAO_Perfect_Hash_ObjTable::~TAO_Perfect_Hash_ObjTable (void)
+{
+}
+
+int
+TAO_Perfect_Hash_ObjTable::bind (const CORBA_OctetSeq &key, CORBA_Object_ptr obj)
+{
+ struct object_db *entry;
+
+ ACE_CString objkey ((char *)key.buffer, key.length);
+ entry = this->hash_->in_word_set (objkey.rep (), key.length);
+ if (entry != 0)
+ {
+ // now fill up the entry
+ entry->obj = obj;
+ }
+ else
+ {
+ return -1; // error
+ }
+}
+
+int
+TAO_Perfect_Hash_ObjTable::find (const CORBA_OctetSeq &key, CORBA_Object_ptr &obj)
+{
+ struct object_db *entry;
+
+ ACE_CString objkey ((char *)key.buffer, key.length);
+ entry = this->hash_->in_word_set (objkey.rep (), key.length);
+
+ if (entry != 0)
+ {
+ obj = entry->obj;
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+//****************** perf hash for opname lookup *************
+struct method_db
+{
+ char *name; // name of method
+ TAO_Skeleton skel_ptr_; //fn pointer to obj impl
+};
+
+#include "gperf_method.i"
+
+// Perfect hash table class
+class TAO_Perfect_Hash_Op_Table: public TAO_Operation_Table
+{
+public:
+ TAO_Perfect_Hash_Op_Table (Method_Hash *mh);
+
+ ~TAO_Perfect_Hash_Op_Table (void);
+
+ virtual int find (const CORBA_String &opname,
+ TAO_Skeleton &skel_ptr);
+ // Uses <{opname}> to look up the skeleton function and pass it back
+ // in <{skelfunc}>. Returns non-negative integer on success, or -1
+ // on failure.
+
+ virtual int bind (const CORBA_String &opname,
+ const TAO_Skeleton skelptr);
+ // Associate the skeleton <{skel_ptr}> with an operation named
+ // <{opname}>. Returns -1 on failure, 0 on success, 1 on duplicate.
+private:
+ Method_Hash *hash_;
+};
+
+TAO_Perfect_Hash_Op_Table::TAO_Perfect_Hash_Op_Table (Method_Hash *mh)
+ : hash_ (mh)
+{
+}
+
+TAO_Perfect_Hash_Op_Table::~TAO_Perfect_Hash_Op_Table (void)
+{
+}
+
+int
+TAO_Perfect_Hash_Op_Table::bind (const CORBA_String &opname,
+ const TAO_Skeleton skelptr)
+{
+ return 0; // nothing to do
+}
+
+int
+TAO_Perfect_Hash_Op_Table::find (const CORBA_String &opname,
+ TAO_Skeleton &skelptr)
+{
+ method_db *entry;
+
+ entry = (method_db*) this->hash_->in_word_set (opname, ACE_OS::strlen (opname));
+ if (entry != 0)
+ {
+ skelptr = entry->skel_ptr_;
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+//***********************************************************
+char Usage[] = "\
+Usage: server [options] \n\
+Common options:\n\
+-t demux_strategy: l(linear), g(GPERF), a (delayered active demux), d (dynamic hash)\n\
+-i iter: number of iterations to expect from client \n\
+";
+
+extern CORBA_Double TAO_Avg;
+extern CORBA_Long TAO_HowMany;
+extern CORBA_Long TAO_Loop;
+int
+main (int argc, char *const *argv)
+{
+ unsigned long addr_tmp;
+ int c;
+ unsigned short done = 0;
+ CORBA_Environment env;
+ CORBA_ORB_ptr orb_ptr;
+ CORBA_POA_ptr oa_ptr;
+ int iter = 1;
+ TAO_OA_Parameters *params = TAO_OA_PARAMS::instance();
+ char *orb_name = "ior";
+ int idle = -1;
+ int use_ior = 0;
+ int terminationStatus = 0;
+ tao_demux_i **mymux; // array of objects implementing the "demux" interface
+ int numObjs = 5, numMethods = 4;
+ Object_Hash oh;
+ TAO_Object_Table *objt = new TAO_Perfect_Hash_ObjTable (&oh);
+ Method_Hash mh;
+ TAO_Operation_Table *optbl = new TAO_Perfect_Hash_Op_Table (&mh);
+
+ TAO_Operation_Table_Parameters *op_params =
+ TAO_OP_TABLE_PARAMETERS::instance();
+
+ fstream iorfile; // stores the object references of all the objects
+ fstream outfile;
+ CORBA_String str; // scratch area
+
+ params->userdef_lookup_strategy (objt);
+
+ orb_ptr = CORBA_ORB_init (argc, argv, orb_name, env);
+ if (env.exception () != 0) {
+ print_exception (env.exception (), "ORB init", stdout);
+ return 1;
+ }
+
+ oa_ptr = orb_ptr->BOA_init (argc, argv, "ROA");
+ if (env.exception () != 0) {
+ print_exception (env.exception (), "OA init", stdout);
+ return 1;
+ }
+
+ TAO_debug_level = 0;
+ // Now process the options other than Orbix specific options
+ while ((c = getopt (argc, argv, "ui:t:o:m:")) != -1)
+ {
+ switch (c)
+ {
+ case 't':
+ switch (*optarg)
+ {
+ case 'l':
+ op_params->lookup_strategy
+ (TAO_Operation_Table_Parameters::TAO_LINEAR);
+ break;
+ case 'a':
+ op_params->lookup_strategy
+ (TAO_Operation_Table_Parameters::TAO_ACTIVE_DEMUX);
+ break;
+ case 'g':
+ op_params->lookup_strategy
+ (TAO_Operation_Table_Parameters::TAO_PERFECT_HASH);
+ op_params->concrete_strategy (optbl);
+ break;
+ case 'd':
+ default:
+ op_params->lookup_strategy
+ (TAO_Operation_Table_Parameters::TAO_DYNAMIC_HASH);
+ break;
+ }
+ break;
+ case 'u':
+ use_ior = 1;
+ orb_name = "";
+ break;
+ case 'i':
+ iter = atoi (optarg);
+ break;
+ case 'o':
+ numObjs = atoi(optarg);
+ break;
+ case 'm':
+ numMethods = atoi(optarg);
+ break;
+ default:
+ goto usage;
+ }
+ }
+
+ TAO_Avg = 0;
+ TAO_Loop = 0;
+ TAO_HowMany = iter*numObjs*numMethods;
+
+ //
+ // Receiver
+ //
+
+ iorfile.open ("ior.txt", ios::out);
+ mymux = new tao_demux_i* [numObjs];
+
+ // instantiate objects
+#include "obj_create.i"
+ iorfile.close();
+ cout << "Server ready to handle events" << endl;
+
+#if defined (USE_QUANTIFY)
+ quantify_clear_data();
+ quantify_start_recording_data();
+#endif
+
+ ACE_Service_Config::run_reactor_event_loop();
+
+ outfile.open ("muxcost.dat", ios::out|ios::app);
+ outfile << numObjs << "\t" << numMethods << "\t" << TAO_Avg << endl;
+ outfile.close ();
+ //
+ // Shut down the OA -- recycles all underlying resources (e.g. file
+ // descriptors, etc).
+ //
+ oa_ptr->clean_shutdown (env);
+ return terminationStatus;
+usage:
+ fprintf (stderr, Usage);
+ return(1);
+}
+
View Lorry Controller Status