TAO/examples/RTScheduling/MIF_Scheduler/MIF_Task.cpp

   1 #include "MIF_Task.h"
   2 #include "test.h"
   3
   4 #include "ace/OS_NS_errno.h"
   5 #include "ace/Countdown_Time.h"
   6
   7 MIF_Task::MIF_Task (int importance,
   8                     time_t start_time,
   9                     int load,
  10                     int iter,
  11                     int dist,
  12                     char *job_name,
  13                     DT_Creator *dt_creator)
  14 {
  15   this->load_ = load;
  16   this->iter_ = iter;
  17   this->start_time_ = start_time;
  18   this->importance_ = importance;
  19   this->dt_creator_ = dt_creator;
  20   this->dist_ = dist;
  21   this->job_name_ = CORBA::string_dup (job_name);
  22
  23   // create the stat object.
  24   ACE_NEW (task_stats_, Task_Stats);
  25   task_stats_->init (iter_);
  26
  27 }
  28
  29 MIF_Task::~MIF_Task (void)
  30 {
  31   delete task_stats_;
  32 }
  33
  34 void
  35 MIF_Task::pre_activate (void)
  36 {
  37   DT_TEST::instance ()->scheduler ()->incr_thr_count ();
  38 }
  39
  40 void
  41 MIF_Task::post_activate (void)
  42 {
  43   DT_TEST::instance ()->scheduler ()->wait ();
  44 }
  45
  46 int
  47 MIF_Task::activate_task (RTScheduling::Current_ptr current,
  48        CORBA::Policy_ptr sched_param,
  49        long flags,
  50        ACE_Time_Value* base_time)
  51 {
  52
  53   if (TAO_debug_level > 0)
  54     ACE_DEBUG ((LM_DEBUG,
  55     "MIF_Task::activate %d\n",
  56     importance_));
  57
  58   char msg [BUFSIZ];
  59   ACE_OS::sprintf (msg, "MIF_Task::activate task\n");
  60   dt_creator_->log_msg (msg);
  61
  62   base_time_ = base_time;
  63
  64   current_ = RTScheduling::Current::_narrow (current);
  65
  66   sched_param_ = CORBA::Policy::_duplicate (sched_param);
  67
  68   pre_activate ();
  69
  70   if (this->activate (flags,
  71           1) == -1)
  72     {
  73       if (ACE_OS::last_error () == EPERM)
  74   ACE_ERROR_RETURN ((LM_ERROR,
  75          ACE_TEXT ("Insufficient privilege to run this test.\n")),
  76         -1);
  77     }
  78
  79   post_activate ();
  80   return 0;
  81 }
  82
  83 int
  84 MIF_Task::perform_task (void)
  85 {
  86   try
  87     {
  88
  89       ACE_TCHAR msg [BUFSIZ];
  90       ACE_OS::sprintf (msg,
  91                        ACE_TEXT("MIF_Task::perform_task ")
  92                        ACE_SIZE_T_FORMAT_SPECIFIER
  93                        ACE_TEXT("\n"),
  94                        count_);
  95       dt_creator_->log_msg (ACE_TEXT_ALWAYS_CHAR(msg));
  96
  97       static CORBA::ULong prime_number = 9619;
  98       CORBA::Policy_var sched_param;
  99       sched_param = dt_creator_->sched_param (this->importance_);
 100       const char * name = 0;
 101
 102       for (int i = 0; i < this->iter_; i++)
 103         {
 104           ACE_Time_Value run_time = ACE_OS::gettimeofday () - *base_time_;
 105           TASK_STATS::instance ()->sample (run_time.sec (), count_);
 106
 107           ACE_Time_Value count_down_time (1);
 108           ACE_Countdown_Time count_down (&count_down_time);
 109
 110           while (count_down_time > ACE_Time_Value::zero)
 111             {
 112               ACE::is_prime (prime_number,
 113                              2,
 114                              prime_number / 2);
 115
 116               count_down.update ();
 117             }
 118
 119           current_->update_scheduling_segment (name,
 120                                                sched_param.in (),
 121                                                sched_param.in ());
 122         }
 123
 124       if (this->dist_)
 125         {
 126           this->job_->work (this->load_,
 127                             this->importance_);
 128
 129           for (int j = 0; j < this->iter_; j++)
 130             {
 131               ACE_Time_Value run_time = ACE_OS::gettimeofday () - *base_time_;
 132               TASK_STATS::instance ()->sample (run_time.sec (), count_);
 133
 134               ACE_Time_Value count_down_time (1);
 135               ACE_Countdown_Time count_down (&count_down_time);
 136
 137               while (count_down_time > ACE_Time_Value::zero)
 138                 {
 139
 140                   ACE::is_prime (prime_number,
 141                                  2,
 142                                  prime_number / 2);
 143                   count_down.update ();
 144                 }
 145
 146               current_->update_scheduling_segment (name,
 147                                                    sched_param.in (),
 148                                                    sched_param.in ());
 149
 150             }
 151
 152         }
 153
 154     }
 155   catch (const CORBA::Exception& ex)
 156     {
 157       ex._tao_print_exception ("Caught exception:");
 158       return -1;
 159     }
 160
 161   if (TAO_debug_level > 0)
 162     ACE_DEBUG ((LM_DEBUG,
 163     "Thread %d\n",
 164     this->count_));
 165
 166   if (dist_)
 167     job_->shutdown ();
 168
 169   return 0;
 170 }