TAO/examples/RTScheduling/POA_Holder.cpp

   1 #include "POA_Holder.h"
   2
   3 #include "tao/debug.h"
   4
   5 #include "ace/Arg_Shifter.h"
   6 #include "ace/Log_Msg.h"
   7
   8 POA_Holder::POA_Holder (void)
   9   :priority_model_ (RTCORBA::CLIENT_PROPAGATED),
  10    server_priority_ (0),
  11    thread_pool_ (0)
  12   {
  13   }
  14
  15 int
  16 POA_Holder::init (ACE_Arg_Shifter& arg_shifter)
  17 {
  18   ACE_DEBUG ((LM_DEBUG,
  19         "Init POA\n"));
  20
  21   const ACE_TCHAR *current_arg = 0;
  22
  23   POA_name_ = ACE_TEXT_ALWAYS_CHAR(arg_shifter.get_current ()); // Read the name of the POA
  24   arg_shifter.consume_arg ();
  25
  26   while (arg_shifter.is_anything_left ())
  27     {
  28       if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-PriorityModel"))))
  29         {
  30           if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("CLIENT")) == 0)
  31             priority_model_ = RTCORBA::CLIENT_PROPAGATED;
  32           else
  33             priority_model_ = RTCORBA::SERVER_DECLARED;
  34           arg_shifter.consume_arg ();
  35
  36           server_priority_ = ACE_OS::atoi (current_arg);
  37           arg_shifter.consume_arg ();
  38         }
  39       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Lanes"))))
  40         {
  41           int lanecount = ACE_OS::atoi (current_arg);
  42           lanes_.length (lanecount);
  43           arg_shifter.consume_arg ();
  44
  45           int l_index = 0;
  46           //parse lane values ...
  47           while (arg_shifter.is_anything_left ())
  48             {
  49               if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Lane")) == 0)
  50                 {
  51                   arg_shifter.consume_arg ();
  52
  53                   // read priority
  54                   lanes_[l_index].lane_priority = ACE_OS::atoi (arg_shifter.get_current ());
  55                   arg_shifter.consume_arg ();
  56
  57                   // static thread count
  58                   lanes_[l_index].static_threads = ACE_OS::atoi (arg_shifter.get_current ());
  59                   arg_shifter.consume_arg ();
  60
  61                   // dynamic thread count
  62                   lanes_[l_index].dynamic_threads = ACE_OS::atoi (arg_shifter.get_current ());
  63                   arg_shifter.consume_arg ();
  64
  65                   //if (TAO_debug_level > 0)
  66                   ACE_DEBUG ((LM_DEBUG, "lane parsed - %d, %d, %d\n",
  67                               lanes_[l_index].lane_priority, lanes_[l_index].static_threads, lanes_[l_index].dynamic_threads));
  68                   l_index++;
  69                 }
  70         else
  71                 break;
  72             } /* while -- lane values */
  73
  74         } /* if -Lanes */
  75       else if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-ThreadPool")) == 0)
  76   {
  77     ACE_DEBUG ((LM_DEBUG,
  78           "Thread Pool\n"));
  79
  80     arg_shifter.consume_arg ();
  81     thread_pool_ = 1;
  82     // read priority
  83     tp_static_threads_ = ACE_OS::atoi (arg_shifter.get_current ());
  84     arg_shifter.consume_arg ();
  85
  86     tp_dynamic_threads_ = ACE_OS::atoi (arg_shifter.get_current ());
  87     arg_shifter.consume_arg ();
  88
  89     tp_priority_ = ACE_OS::atoi (arg_shifter.get_current ());
  90     arg_shifter.consume_arg ();
  91     ACE_DEBUG ((LM_DEBUG,
  92           "Thread Pool Initialized\n"));
  93
  94   }
  95       else if (0 != (current_arg = arg_shifter.get_the_parameter (ACE_TEXT("-Bands"))))
  96         {
  97     ACE_DEBUG ((LM_DEBUG,
  98           "Initializing Bands\n"));
  99
 100           int bandcount = ACE_OS::atoi (current_arg);
 101           bands_.length (bandcount);
 102           arg_shifter.consume_arg ();
 103
 104           int b_index = 0;
 105           //parse band values ...
 106           while (arg_shifter.is_anything_left ())
 107             {
 108               if (arg_shifter.cur_arg_strncasecmp (ACE_TEXT("-Band")) == 0)
 109                 {
 110                   arg_shifter.consume_arg ();
 111
 112                   // read low
 113                   bands_[b_index].low = ACE_OS::atoi (arg_shifter.get_current ());
 114                   arg_shifter.consume_arg ();
 115
 116                   // read high
 117                   bands_[b_index].high = ACE_OS::atoi (arg_shifter.get_current ());
 118                   arg_shifter.consume_arg ();
 119
 120                   //if (TAO_debug_level > 0)
 121                   ACE_DEBUG ((LM_DEBUG, "band parsed - %d, %d\n",
 122                               bands_[b_index].low, bands_[b_index].high));
 123                   b_index++;
 124                 }
 125               else
 126                 break;
 127             } /* while -- Band values */
 128     ACE_DEBUG ((LM_DEBUG,
 129           "Bands Initialized\n"));
 130
 131         } /* if -Bands */
 132       else // something else is showing up ...
 133         {
 134     ACE_DEBUG ((LM_DEBUG,
 135           "Finish Init POA\n"));
 136
 137           return 0;
 138         }
 139     }
 140   ACE_DEBUG ((LM_DEBUG,
 141         "Finish Init POA\n"));
 142   return 0;
 143 }
 144
 145 void
 146 POA_Holder::activate (RTCORBA::RTORB_ptr rt_orb, PortableServer::POA_ptr parent_poa)
 147 {
 148   CORBA::Policy_var priority_model_policy;
 149   CORBA::Policy_var lanes_policy;
 150   CORBA::Policy_var bands_policy;
 151   CORBA::Policy_var thread_pool_policy;
 152
 153   // Create a priority model policy.
 154   priority_model_policy =
 155     rt_orb->create_priority_model_policy (priority_model_,
 156                                           server_priority_);
 157
 158   if (lanes_.length () != 0)
 159     {
 160       // Create a thread-pool.
 161       CORBA::ULong stacksize = 0;
 162       CORBA::Boolean allow_request_buffering = 0;
 163       CORBA::ULong max_buffered_requests = 0;
 164       CORBA::ULong max_request_buffer_size = 0;
 165       CORBA::Boolean allow_borrowing = 0;
 166
 167       // Create the thread-pool.
 168       RTCORBA::ThreadpoolId threadpool_id =
 169         rt_orb->create_threadpool_with_lanes (stacksize,
 170                                               lanes_,
 171                                               allow_borrowing,
 172                                               allow_request_buffering,
 173                                               max_buffered_requests,
 174                                               max_request_buffer_size);
 175
 176       // Create a thread-pool policy.
 177       lanes_policy =
 178         rt_orb->create_threadpool_policy (threadpool_id);
 179
 180       ACE_DEBUG ((LM_DEBUG,
 181       "Activated Lanes\n"));
 182
 183     }
 184
 185   if (thread_pool_)
 186     {
 187       CORBA::ULong stacksize = 0;
 188       CORBA::Boolean allow_request_buffering = 0;
 189       CORBA::ULong max_buffered_requests = 0;
 190       CORBA::ULong max_request_buffer_size = 0;
 191
 192       RTCORBA::ThreadpoolId threadpool_id_1 =
 193         rt_orb->create_threadpool (stacksize,
 194                                    tp_static_threads_,
 195                                    tp_dynamic_threads_,
 196                                    tp_priority_,
 197                                    allow_request_buffering,
 198                                    max_buffered_requests,
 199                                    max_request_buffer_size);
 200
 201
 202       thread_pool_policy = rt_orb->create_threadpool_policy (threadpool_id_1);
 203
 204       ACE_DEBUG ((LM_DEBUG,
 205       "Activated thread pool\n"));
 206
 207
 208     }
 209
 210   if (bands_.length () != 0)
 211     {
 212       // Create a bands policy.
 213       bands_policy =
 214         rt_orb->create_priority_banded_connection_policy (this->bands_);
 215       ACE_DEBUG ((LM_DEBUG,
 216       "Activated Bands\n"));
 217
 218     }
 219
 220   CORBA::PolicyList poa_policy_list;
 221
 222   if (lanes_.length () == 0 && bands_.length () == 0)
 223     {
 224       if (thread_pool_)
 225   {
 226     poa_policy_list.length (2);
 227     poa_policy_list[0] = priority_model_policy;
 228     poa_policy_list[1] = thread_pool_policy;
 229   }
 230       else
 231   {
 232     poa_policy_list.length (1);
 233     poa_policy_list[0] = priority_model_policy;
 234   }
 235     }
 236   else if (lanes_.length () != 0 && bands_.length () == 0)
 237     {
 238       if (thread_pool_)
 239   {
 240     poa_policy_list.length (3);
 241     poa_policy_list[0] = priority_model_policy;
 242     poa_policy_list[1] = lanes_policy;
 243     poa_policy_list[2] = thread_pool_policy;
 244   }
 245       else
 246   {
 247     poa_policy_list.length (2);
 248     poa_policy_list[0] = priority_model_policy;
 249     poa_policy_list[1] = lanes_policy;
 250   }
 251     }
 252   else if (lanes_.length () == 0 && bands_.length () != 0)
 253     {
 254       if (thread_pool_)
 255   {
 256     poa_policy_list.length (3);
 257     poa_policy_list[0] = priority_model_policy;
 258     poa_policy_list[1] = bands_policy;
 259     poa_policy_list[2] = thread_pool_policy;
 260   }
 261       else
 262   {
 263     poa_policy_list.length (2);
 264     poa_policy_list[0] = priority_model_policy;
 265     poa_policy_list[1] = bands_policy;
 266   }
 267     }
 268   else
 269     {
 270       if (thread_pool_)
 271   {
 272     poa_policy_list.length (4);
 273     poa_policy_list[0] = priority_model_policy;
 274     poa_policy_list[1] = lanes_policy;
 275     poa_policy_list[2] = bands_policy;
 276     poa_policy_list[3] = thread_pool_policy;
 277   }
 278       else
 279   {
 280     poa_policy_list.length (3);
 281     poa_policy_list[0] = priority_model_policy;
 282     poa_policy_list[1] = lanes_policy;
 283     poa_policy_list[2] = bands_policy;
 284   }
 285     }
 286
 287   ACE_DEBUG ((LM_DEBUG,
 288         "Initialized POA Policy\n"));
 289
 290   if (TAO_debug_level > 0)
 291     ACE_DEBUG ((LM_DEBUG, "creating POA %C\n", POA_name_.c_str ()));
 292
 293   // Get the POA Manager.
 294   PortableServer::POAManager_var poa_manager =
 295     parent_poa->the_POAManager ();
 296
 297   PortableServer::POA_var poa =
 298     parent_poa->create_POA (POA_name_.c_str (),
 299                             poa_manager.in (),
 300                             poa_policy_list);
 301 }