TAO/examples/Simulator/Event_Supplier/Logging_Sup.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Logging_Sup.cpp
   5  *
   6  * Event Supplier for visualizing scheduling behavior, using arrival
   7  * and dispatch data logged by an event channel dispatch command object
   8  *
   9  *  @author Chris Gill (cdgill@cs.wustl.edu) Adapted from the DOVE simulation event supplier originally David Levine (levine@cs.wustl.edu) and Tim Harrison (harrison@cs.wustl.edu) modified Michael Kircher (mk1@cs.wustl.edu)
  10  */
  11 //=============================================================================
  12
  13
  14 #include "Logging_Sup.h"
  15 #include "NavWeapC.h"
  16
  17 #include "orbsvcs/Event_Utilities.h"
  18 #include "orbsvcs/Event_Service_Constants.h"
  19 #include "orbsvcs/Scheduler_Factory.h"
  20 #include "orbsvcs/RtecEventChannelAdminC.h"
  21
  22 #include "tao/Utils/ORB_Manager.h"
  23
  24 #include "ace/Get_Opt.h"
  25 #include "ace/Sched_Params.h"
  26 #include "ace/OS_NS_stdio.h"
  27 #include "ace/OS_NS_unistd.h"
  28 #include "ace/OS_NS_string.h"
  29 #include "ace/OS_NS_ctype.h"
  30
  31 static const char usage [] =
  32 "[[-?]\n"
  33 "                 [-O[RBport] ORB port number]\n"
  34 "                 [-m <count> of messages to send [100]\n"
  35 "                 [-f name of scheduler input data file]\n"
  36 "                 [-d name of scheduler header dump file]\n"
  37 "                 [-s to suppress data updates by EC]]\n";
  38
  39
  40 Logging_Supplier::Logging_Supplier (int argc, ACE_TCHAR** argv)
  41 : argc_(argc),
  42   argv_(argv),
  43   total_messages_(10),
  44   input_file_name_(0),
  45   update_data_ (1),
  46   schedule_file_name_(0)
  47 {
  48   navigation_.roll = navigation_.pitch = 0;
  49 }
  50
  51 Logging_Supplier::~Logging_Supplier ()
  52 {
  53   this->dOVE_Supplier_.disconnect ();
  54 }
  55
  56 int
  57 Logging_Supplier::init ()
  58 {
  59   this->get_options (argc_, argv_);
  60   return this->dOVE_Supplier_.connect ();
  61 }
  62
  63 void
  64 Logging_Supplier::start_generating_events ()
  65 {
  66   unsigned long total_sent = 0;
  67
  68   // Load the scheduling data for the simulation.
  69   ACE_Unbounded_Queue<Schedule_Viewer_Data *> schedule_data;
  70   this->load_schedule_data (schedule_data);
  71   ACE_Unbounded_Queue_Iterator<Schedule_Viewer_Data *>
  72     schedule_iter (schedule_data);
  73
  74   if (schedule_iter.done ())
  75     {
  76       ACE_ERROR ((LM_ERROR,
  77                   "DOVE_Supplier::start_generating_events: "
  78                   "there is no scheduling data\n"));
  79       return;
  80     }
  81
  82   CORBA::Any any;
  83
  84   do
  85   {
  86   // Insert the event data
  87     this->insert_event_data (any,
  88                              schedule_iter);
  89
  90     // deliver it over the wire
  91     dOVE_Supplier_.notify (any);
  92
  93     if (total_sent < 5)
  94       ACE_DEBUG ((LM_DEBUG,
  95                   "Pushing event data.\n"));
  96     else if (total_sent == 5)
  97       ACE_DEBUG ((LM_DEBUG,
  98                   "Everything is running. Going to be mute.\n"));
  99   }
 100   while (++total_sent < this->total_messages_);
 101
 102   // clean up the scheduling data
 103   Schedule_Viewer_Data **data_temp;
 104   for (schedule_iter.first ();
 105        schedule_iter.done () == 0;
 106        schedule_iter.advance ())
 107     if (schedule_iter.next (data_temp) && data_temp)
 108       delete (*data_temp);
 109 }
 110
 111 void
 112 Logging_Supplier::load_schedule_data
 113       (ACE_Unbounded_Queue<Schedule_Viewer_Data *> &schedule_data)
 114 {
 115   Schedule_Viewer_Data *data = 0;
 116
 117   if (this->input_file_name_)
 118     {
 119       // Open the scheduler data input file and read its contents into
 120       // a queue.
 121       FILE *input_file;
 122
 123       int scan_count = 0;
 124       input_file = ACE_OS::fopen(this->input_file_name_, "r");
 125
 126       if (input_file)
 127         {
 128           // Get a line at a time from the data file and parse it.
 129           char input_buf[BUFSIZ];
 130           while (ACE_OS::fgets (input_buf, BUFSIZ, input_file))
 131             {
 132               // Run through leading whitespace.
 133               char *temp = input_buf;
 134               while (*temp && ACE_OS::ace_isspace (*temp))
 135                 ++temp;
 136
 137               // If there is anything besides whitespace in the line
 138               // read, scan its fields into the scheduling data
 139               // structure.
 140               if (ACE_OS::strlen (temp) > 0)
 141                 {
 142                   ACE_NEW (data, Schedule_Viewer_Data);
 143                   scan_count = sscanf (temp, "%s %lf %lf %lu %lu %lu %lu",
 144                                        data->operation_name,
 145                                        &data->utilitzation,
 146                                        &data->overhead,
 147                                        &data->arrival_time,
 148                                        &data->deadline_time,
 149                                        &data->completion_time,
 150                                        &data->computation_time);
 151                   if (scan_count != 7)
 152                     {
 153                       ACE_ERROR ((LM_ERROR,
 154                                   "DOVE_Supplier::start_generating_events: "
 155                                   "scanned incorrect number of data elements: %d\n", scan_count));
 156
 157                       delete data;
 158                       return;
 159                     }
 160
 161                   // Insert the data into the queue.
 162                   schedule_data.enqueue_tail (data);
 163                 }
 164             }
 165         }
 166       else
 167         {
 168           ACE_ERROR ((LM_ERROR,
 169                       "DOVE_Supplier::start_generating_events: "
 170                       "could not open input file [%s].\n",
 171                       this->input_file_name_));
 172           return;
 173         }
 174     }
 175   else
 176   {
 177     u_long last_completion = 0;
 178
 179     // Just create 10 dummy scheduling records and use them.
 180     for (int i = 0; i < 10; ++i)
 181     {
 182       ACE_NEW (data, Schedule_Viewer_Data);
 183
 184       const char *oper_name = 0;
 185       switch (i % 4)
 186       {
 187       case 0:
 188         oper_name = "high_20";
 189         break;
 190
 191       case 1:
 192         oper_name = "low_20";
 193         break;
 194
 195       case 2:
 196         oper_name = "high_10";
 197         break;
 198
 199       case 3:
 200       default:
 201         oper_name = "low_10";
 202         break;
 203       }
 204
 205       ACE_OS::strncpy (data->operation_name,
 206                        oper_name,
 207                        BUFSIZ-1);
 208
 209       data->utilitzation = (double)(20.0+ACE_OS::rand() %10);
 210       data->overhead = (double)(ACE_OS::rand() %20);
 211
 212       data->arrival_time = ACE_OS::rand() % 200;
 213       data->computation_time = (ACE_OS::rand() % 100) + 10;
 214
 215       data->completion_time = last_completion + (ACE_OS::rand() % 100) + 100;
 216       data->completion_time =
 217         data->completion_time <  data->arrival_time + data->computation_time
 218         ? data->arrival_time + data->computation_time
 219         : data->completion_time;
 220
 221       last_completion = data->completion_time;
 222
 223       data->deadline_time = data->completion_time + (ACE_OS::rand() % 200) - 50;
 224
 225       // insert the data into the queue.
 226       schedule_data.enqueue_tail (data);
 227     }
 228   }
 229 }
 230
 231 // This function fills in the random data into the anys transported by
 232 // the event channel.
 233
 234 void
 235 Logging_Supplier::insert_event_data (CORBA::Any &data,
 236                                   ACE_Unbounded_Queue_Iterator<Schedule_Viewer_Data *> &schedule_iter)
 237 {
 238   static u_long last_completion = 0;
 239
 240   // constants for periods (in units of one hundred nanoseconds)
 241   const TimeBase::TimeT ONE_HZ_PERIOD = 10000000;
 242   const TimeBase::TimeT FIVE_HZ_PERIOD = ONE_HZ_PERIOD / 5 ;
 243   const TimeBase::TimeT TEN_HZ_PERIOD = ONE_HZ_PERIOD / 10;
 244   const TimeBase::TimeT TWENTY_HZ_PERIOD = ONE_HZ_PERIOD / 20;
 245
 246   try
 247   {
 248     Schedule_Viewer_Data **sched_data;
 249
 250     if ((schedule_iter.next (sched_data)) && (sched_data) && (*sched_data))
 251     {
 252       if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_20") == 0) ||
 253            (ACE_OS::strcmp((*sched_data)->operation_name, "low_20") == 0)  ||
 254            (ACE_OS::strcmp((*sched_data)->operation_name, "high_1") == 0)  ||
 255            (ACE_OS::strcmp((*sched_data)->operation_name, "low_1") == 0))
 256       {
 257         if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_20") == 0) ||
 258             (ACE_OS::strcmp((*sched_data)->operation_name, "high_1") == 0))
 259           {
 260             navigation_.criticality = 1;
 261           }
 262         else
 263           {
 264             navigation_.criticality = 0;
 265           }
 266
 267         if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_20") == 0) ||
 268             (ACE_OS::strcmp((*sched_data)->operation_name, "low_20") == 0))
 269           {
 270             navigation_.deadline_time = TWENTY_HZ_PERIOD;
 271           }
 272         else
 273           {
 274             navigation_.deadline_time = ONE_HZ_PERIOD;
 275           }
 276
 277         navigation_.position_latitude = ACE_OS::rand() % 90;
 278         navigation_.position_longitude = ACE_OS::rand() % 180;
 279         navigation_.altitude = ACE_OS::rand() % 100;
 280         navigation_.heading = ACE_OS::rand() % 180;
 281         navigation_.roll = (navigation_.roll >= 180) ? -180 : navigation_.roll + 1;
 282         navigation_.pitch =  (navigation_.pitch >= 90) ? -90 : navigation_.pitch + 1;
 283
 284         navigation_.utilization =       0.0;
 285         navigation_.overhead =          0.0;
 286         navigation_.arrival_time =      ORBSVCS_Time::zero ();
 287         navigation_.completion_time =   ORBSVCS_Time::zero ();
 288         navigation_.computation_time =  ORBSVCS_Time::zero ();
 289         navigation_.update_data =       update_data_;
 290
 291
 292         // because the scheduler data does not supply these values
 293         navigation_.utilization = (double) (20.0 + ACE_OS::rand() % 10);
 294         navigation_.overhead = (double) (ACE_OS::rand() % 10);
 295
 296         data <<= navigation_;
 297       }
 298       else if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_10") == 0) ||
 299                (ACE_OS::strcmp((*sched_data)->operation_name, "low_10") == 0)  ||
 300                 (ACE_OS::strcmp((*sched_data)->operation_name, "high_5") == 0)  ||
 301                 (ACE_OS::strcmp((*sched_data)->operation_name, "low_5") == 0))
 302       {
 303         if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_10") == 0) ||
 304             (ACE_OS::strcmp((*sched_data)->operation_name, "high_5") == 0))
 305           {
 306             weapons_.criticality = 1;
 307           }
 308         else
 309           {
 310             weapons_.criticality = 0;
 311           }
 312
 313         if ((ACE_OS::strcmp((*sched_data)->operation_name, "high_10") == 0) ||
 314             (ACE_OS::strcmp((*sched_data)->operation_name, "low_10") == 0))
 315           {
 316             weapons_.deadline_time = TEN_HZ_PERIOD;
 317           }
 318         else
 319           {
 320             weapons_.deadline_time = FIVE_HZ_PERIOD;
 321           }
 322
 323
 324         weapons_.number_of_weapons = 2;
 325         weapons_.weapon1_identifier = CORBA::string_alloc (30);
 326         ACE_OS::strcpy (weapons_.weapon1_identifier.inout (),"Photon Torpedoes");
 327         weapons_.weapon1_status =(ACE_OS::rand() % 4) == 0 ? 0 : 1 ;
 328         weapons_.weapon2_identifier = CORBA::string_alloc (30);
 329         ACE_OS::strcpy (weapons_.weapon2_identifier.inout (),"Quantum Torpedoes");
 330         weapons_.weapon2_status = (ACE_OS::rand() % 4) == 0 ? 0 : 1;
 331         weapons_.weapon3_identifier = CORBA::string_alloc (1);
 332         ACE_OS::strcpy (weapons_.weapon3_identifier.inout (), "");
 333         weapons_.weapon3_status = 0;
 334         weapons_.weapon4_identifier = CORBA::string_alloc (1);
 335         ACE_OS::strcpy (weapons_.weapon4_identifier.inout (), "");
 336         weapons_.weapon4_status = 0;
 337         weapons_.weapon5_identifier = CORBA::string_alloc (1);
 338         ACE_OS::strcpy (weapons_.weapon5_identifier.inout (), "");
 339         weapons_.weapon5_status = 0;
 340         weapons_.utilization =       0.0;
 341         weapons_.overhead =          0.0;
 342         weapons_.arrival_time =      ORBSVCS_Time::zero ();
 343         weapons_.completion_time  =  ORBSVCS_Time::zero ();
 344         weapons_.computation_time =  ORBSVCS_Time::zero ();
 345         weapons_.update_data =       update_data_;
 346
 347
 348         data <<= weapons_;
 349       }
 350       else {
 351         ACE_ERROR ((LM_ERROR,
 352                     "Logging_Supplier::insert_event_data:"
 353                     "unrecognized operation name [%s]",
 354                     (*sched_data)->operation_name));
 355       }
 356
 357
 358             if (last_completion > (*sched_data)->completion_time)
 359               last_completion = 0;
 360
 361       if ((*sched_data)->completion_time >= last_completion)
 362       {
 363               ACE_Time_Value pause (0,
 364                                     (*sched_data)->completion_time -
 365                                       last_completion);
 366               ACE_OS::sleep (pause);
 367               last_completion = (*sched_data)->completion_time;
 368       }
 369     }
 370     else
 371       ACE_ERROR ((LM_ERROR,
 372                   "Logging_Supplier::insert_event_data:"
 373                   "Could Not access scheduling data"));
 374
 375     schedule_iter.advance ();
 376
 377     if (schedule_iter.done ())
 378       schedule_iter.first ();
 379   }
 380   catch (const CORBA::Exception&)
 381   {
 382     ACE_ERROR ((LM_ERROR,
 383                 "(%t)Error in Logging_Supplier::insert_event_data.\n"));
 384   }
 385 }
 386
 387 // Function get_options.
 388 unsigned int
 389 Logging_Supplier::get_options (int argc, ACE_TCHAR *argv [])
 390 {
 391   ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("f:m:d:s"));
 392   int opt;
 393   int temp;
 394
 395   while ((opt = get_opt ()) != -1)
 396     {
 397       switch (opt)
 398         {
 399         case 'm':
 400           temp = ACE_OS::atoi (get_opt.opt_arg ());
 401           if (temp > 0)
 402             {
 403               this->total_messages_ = (u_int) temp;
 404                ACE_DEBUG ((LM_DEBUG,
 405                            "Messages to send: %d\n",
 406                            this->total_messages_));
 407             }
 408           else
 409             ACE_ERROR_RETURN ((LM_ERROR,
 410                                "%s: count must be > 0",
 411                                argv[0]),
 412                                1);
 413           break;
 414         case 'f':
 415           this->input_file_name_ = get_opt.opt_arg ();
 416
 417           if (!this->input_file_name_ || ACE_OS::strlen (this->input_file_name_) > 0)
 418             ACE_DEBUG ((LM_DEBUG,"Reading file!\n"));
 419           else
 420             {
 421               this->input_file_name_ = 0;
 422               ACE_ERROR_RETURN ((LM_ERROR,
 423                                  "%s: file name must be specified with -f option",
 424                                  argv[0]),
 425                                 1);
 426             }
 427           break;
 428         case 'd':
 429           this->schedule_file_name_ = get_opt.opt_arg ();
 430
 431           if (!this->schedule_file_name_ || ACE_OS::strlen (this->schedule_file_name_) > 0)
 432             ACE_DEBUG ((LM_DEBUG,"Dumping file!\n"));
 433           else
 434             {
 435               this->input_file_name_ = 0;
 436               ACE_ERROR_RETURN ((LM_ERROR,
 437                                  "%s: file name must be specified with -d option",
 438                                  argv[0]),
 439                                 1);
 440             }
 441           break;
 442         case 's':
 443           update_data_ = 0;
 444           break;
 445         default:
 446         case '?':
 447           ACE_DEBUG ((LM_DEBUG,
 448                       "Usage: %s %s\n",
 449                       argv[0], usage));
 450           ACE_OS::exit (0);
 451           break;
 452         }
 453     }
 454
 455   if (argc != get_opt.opt_ind ())
 456     ACE_ERROR_RETURN ((LM_ERROR,
 457                        "%s: too many arguments\n"
 458                        "Usage: %s %s\n",
 459                        argv[0],
 460                        argv[0],
 461                        usage),
 462                       1);
 463
 464   return 0;
 465 }
 466
 467 // function main
 468
 469 int
 470 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 471 {
 472   try
 473     {
 474       // Initialize ORB.
 475       TAO_ORB_Manager orb_Manager;
 476
 477       orb_Manager.init (argc,
 478                         argv);
 479
 480
 481       // Create the demo supplier.
 482       Logging_Supplier *event_Supplier_ptr;
 483
 484       ACE_NEW_RETURN (event_Supplier_ptr,
 485                       Logging_Supplier(argc, argv),
 486                       -1);
 487
 488       // Initialize everthing
 489       if (event_Supplier_ptr->init () == -1)
 490         ACE_OS::exit (1);
 491
 492       // now we can go ahead
 493       event_Supplier_ptr->start_generating_events ();
 494
 495       // when done, we clean up
 496       delete event_Supplier_ptr;
 497     }
 498   catch (const CORBA::Exception& ex)
 499     {
 500       ex._tao_print_exception ("SYS_EX");
 501     }
 502
 503   return 0;
 504 }
 505