dep/ACE_wrappers/ace/Monitor_Base.cpp

   1 // $Id: Monitor_Base.cpp 82328 2008-07-15 17:20:17Z parsons $
   2
   3 #include "ace/Monitor_Base.h"
   4
   5 #if defined (ACE_HAS_MONITOR_FRAMEWORK) && (ACE_HAS_MONITOR_FRAMEWORK == 1)
   6
   7 #include "ace/Monitor_Admin_Manager.h"
   8 #include "ace/Monitor_Control_Action.h"
   9 #include "ace/Monitor_Point_Registry.h"
  10 #include "ace/Guard_T.h"
  11 #include "ace/Dynamic_Service.h"
  12 #include "ace/OS_NS_sys_time.h"
  13
  14 #if !defined (__ACE_INLINE__)
  15 #include "ace/Monitor_Base.inl"
  16 #endif /* __ACE_INLINE__ */
  17
  18 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  19
  20 namespace ACE
  21 {
  22   namespace Monitor_Control
  23   {
  24     Monitor_Base::Monitor_Base (const char* name,
  25                                 Monitor_Control_Types::Information_Type type)
  26       : ACE_Refcountable_T<ACE_SYNCH_MUTEX> (1)
  27       , data_ (type)
  28       , name_ (name)
  29     {
  30     }
  31
  32     Monitor_Base::~Monitor_Base (void)
  33     {
  34       ACE_GUARD (ACE_SYNCH_MUTEX, guard, this->mutex_);
  35
  36       if (this->data_.type_ == Monitor_Control_Types::MC_LIST)
  37         {
  38           for (size_t i = 0UL; i < this->data_.index_; ++i)
  39             {
  40               delete [] this->data_.list_[i];
  41             }
  42         }
  43     }
  44
  45     void
  46     Monitor_Base::update (void)
  47     {
  48       /// Overridden in derived classes.
  49     }
  50
  51     void
  52     Monitor_Base::receive (double data)
  53     {
  54       if (this->data_.type_ == Monitor_Control_Types::MC_LIST)
  55         {
  56           ACE_ERROR ((LM_ERROR,
  57                       ACE_TEXT ("receive: can't store numeric value - ")
  58                       ACE_TEXT ("%s is a string type monitor\n"),
  59                       this->name_.c_str ()));
  60           return;
  61         }
  62
  63       ACE_GUARD (ACE_SYNCH_MUTEX, guard, this->mutex_);
  64       this->data_.timestamp_ = ACE_OS::gettimeofday ();
  65       this->data_.value_ = data;
  66
  67       if (this->data_.type_ != Monitor_Control_Types::MC_COUNTER)
  68         {
  69           this->data_.sum_ += data;
  70           this->data_.sum_of_squares_ += (data * data);
  71           ++this->data_.index_;
  72         }
  73
  74       if (this->data_.type_ == Monitor_Control_Types::MC_COUNTER)
  75         {
  76           ++this->data_.last_;
  77           this->data_.maximum_ = this->data_.last_;
  78         }
  79       else
  80         {
  81           this->data_.last_ = data;
  82
  83           if (!this->data_.minimum_set_)
  84             {
  85               this->data_.minimum_set_ = true;
  86               this->data_.minimum_ = data;
  87             }
  88           else if (this->data_.minimum_ > data)
  89             {
  90               this->data_.minimum_ = data;
  91             }
  92
  93           if (this->data_.maximum_ < data)
  94             {
  95               this->data_.maximum_ = data;
  96             }
  97         }
  98     }
  99
 100     void
 101     Monitor_Base::receive (size_t data)
 102     {
 103       this->receive (static_cast<double> (data));
 104     }
 105
 106     void
 107     Monitor_Base::receive (const Monitor_Control_Types::NameList& data)
 108     {
 109       if (this->data_.type_ != Monitor_Control_Types::MC_LIST)
 110         {
 111           ACE_ERROR ((LM_ERROR,
 112                       ACE_TEXT ("receive: can't store string values - ")
 113                       ACE_TEXT ("%s is a numeric type monitor\n"),
 114                       this->name_.c_str ()));
 115           return;
 116         }
 117
 118       ACE_GUARD (ACE_SYNCH_MUTEX, guard, this->mutex_);
 119
 120       for (size_t i = 0UL; i < this->data_.index_; ++i)
 121         {
 122           ACE::strdelete (this->data_.list_[i]);
 123         }
 124
 125       this->data_.index_ = data.size ();
 126       this->data_.list_.max_size (this->data_.index_);
 127
 128       for (size_t i = 0UL; i < this->data_.index_; ++i)
 129         {
 130           this->data_.list_[i] = ACE::strnew (data[i].c_str ());
 131         }
 132     }
 133
 134     long
 135     Monitor_Base::add_constraint (const char* expression,
 136                                   Control_Action* action)
 137     {
 138       /// Thread-safe and guaranteed to be unique.
 139       long id = Monitor_Point_Registry::instance ()->constraint_id ();
 140
 141       CONSTRAINTS::value_type entry;
 142       entry.first = id;
 143       entry.second.expr = expression;
 144       entry.second.control_action = action;
 145
 146       /// This is thread-safe on its own so we don't have
 147       /// to guard it here.
 148       action->add_ref ();
 149
 150       {
 151         ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, -1);
 152
 153         /// Since we know external key is unique,
 154         /// we don't check for failure.
 155         (void) this->constraints_.insert (entry);
 156       }
 157
 158       return id;
 159     }
 160
 161     Control_Action*
 162     Monitor_Base::remove_constraint (const long constraint_id)
 163     {
 164       Control_Action* retval = 0;
 165
 166       {
 167         ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0);
 168
 169         CONSTRAINT_ITERATOR i = this->constraints_.find (constraint_id);
 170
 171         if (i != this->constraints_.end ())
 172           {
 173             retval = i->second.control_action;
 174             (void) this->constraints_.erase (constraint_id);
 175           }
 176       }
 177
 178       return retval;
 179     }
 180
 181     void
 182     Monitor_Base::retrieve (Monitor_Control_Types::Data& data) const
 183     {
 184       ACE_GUARD (ACE_SYNCH_MUTEX, guard, this->mutex_);
 185
 186       data = this->data_;
 187     }
 188
 189     void
 190     Monitor_Base::clear (void)
 191     {
 192       ACE_GUARD (ACE_SYNCH_MUTEX, guard, this->mutex_);
 193
 194       this->clear_i ();
 195     }
 196
 197     void
 198     Monitor_Base::retrieve_and_clear (Monitor_Control_Types::Data& data)
 199     {
 200       ACE_GUARD (ACE_SYNCH_MUTEX, guard, this->mutex_);
 201
 202       data = this->data_;
 203       this->clear_i ();
 204     }
 205
 206     void
 207     Monitor_Base::add_to_registry (const ACE_Time_Value& time)
 208     {
 209       MC_ADMINMANAGER *mgr =
 210         ACE_Dynamic_Service<MC_ADMINMANAGER>::instance ("MC_ADMINMANAGER");
 211
 212       if (!mgr->admin ().monitor_point (this, time))
 213         {
 214           ACE_ERROR ((LM_ERROR,
 215                       "monitor point %s registration failed\n",
 216                       this->name ()));
 217         }
 218     }
 219
 220     void
 221     Monitor_Base::remove_from_registry (void)
 222     {
 223       if (!Monitor_Point_Registry::instance ()->remove (this->name ()))
 224         {
 225 // (JP) There is a problem with this failing on a single ACE_Message_Queue
 226 //      monitor per process. I think it is the message queue associated
 227 //      with the default reactor, maybe because at that low level, ACE
 228 //      is using malloc with placement, then free, which may bypass the
 229 //      normal destructors. In any case, it happens only at shutdown
 230 //      and there seems to be no memory leak.
 231 //          ACE_ERROR ((LM_ERROR,
 232 //                      "monitor point %s unregistration failed\n",
 233 //                      this->name ()));
 234         }
 235     }
 236
 237     double
 238     Monitor_Base::average (void) const
 239     {
 240       if (this->data_.type_ == Monitor_Control_Types::MC_COUNTER
 241           || this->data_.type_ == Monitor_Control_Types::MC_GROUP
 242           || this->data_.type_ == Monitor_Control_Types::MC_LIST)
 243         {
 244           ACE_ERROR_RETURN ((LM_ERROR,
 245                              ACE_TEXT ("average: %s is wrong monitor type\n"),
 246                              this->name_.c_str ()),
 247                             0);
 248         }
 249
 250       ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0.0);
 251
 252       return (this->data_.index_== 0UL
 253               ? 0.0
 254               : this->data_.sum_ / this->data_.index_);
 255     }
 256
 257     double
 258     Monitor_Base::sum_of_squares (void) const
 259     {
 260       if (this->data_.type_ == Monitor_Control_Types::MC_COUNTER
 261           || this->data_.type_ == Monitor_Control_Types::MC_GROUP
 262           || this->data_.type_ == Monitor_Control_Types::MC_LIST)
 263         {
 264           ACE_ERROR_RETURN ((LM_ERROR,
 265                              ACE_TEXT ("sum_of_squares: %s ")
 266                              ACE_TEXT ("is wrong monitor type\n"),
 267                              this->name_.c_str ()),
 268                             0);
 269         }
 270
 271       ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0.0);
 272
 273       return this->data_.sum_of_squares_;
 274     }
 275
 276     size_t
 277     Monitor_Base::count (void) const
 278     {
 279       if (this->data_.type_ == Monitor_Control_Types::MC_GROUP)
 280         {
 281           ACE_ERROR_RETURN ((LM_ERROR,
 282                              ACE_TEXT ("count: %s is a monitor group\n"),
 283                              this->name_.c_str ()),
 284                             0UL);
 285         }
 286
 287       ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0UL);
 288
 289       return (this->data_.type_ == Monitor_Control_Types::MC_COUNTER
 290               ? static_cast<size_t> (this->data_.last_)
 291               : this->data_.index_);
 292     }
 293
 294     double
 295     Monitor_Base::minimum_sample (void) const
 296     {
 297       if (this->data_.type_ == Monitor_Control_Types::MC_GROUP
 298           || this->data_.type_ == Monitor_Control_Types::MC_LIST)
 299         {
 300           ACE_ERROR_RETURN ((LM_ERROR,
 301                              ACE_TEXT ("minimum_sample: %s ")
 302                              ACE_TEXT ("is wrong monitor type\n"),
 303                              this->name_.c_str ()),
 304                             0);
 305         }
 306
 307       ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0.0);
 308
 309       return this->data_.minimum_;
 310     }
 311
 312     double
 313     Monitor_Base::maximum_sample (void) const
 314     {
 315       if (this->data_.type_ == Monitor_Control_Types::MC_GROUP
 316           || this->data_.type_ == Monitor_Control_Types::MC_LIST)
 317         {
 318           ACE_ERROR_RETURN ((LM_ERROR,
 319                              ACE_TEXT ("maximum_sample: %s ")
 320                              ACE_TEXT ("is wrong monitor type\n"),
 321                              this->name_.c_str ()),
 322                             0);
 323         }
 324
 325       ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0.0);
 326
 327       return this->data_.maximum_;
 328     }
 329
 330     double
 331     Monitor_Base::last_sample (void) const
 332     {
 333       if (this->data_.type_ == Monitor_Control_Types::MC_GROUP
 334           || this->data_.type_ == Monitor_Control_Types::MC_LIST)
 335         {
 336           ACE_ERROR_RETURN ((LM_ERROR,
 337                              ACE_TEXT ("last_sample: %s ")
 338                              ACE_TEXT ("is wrong monitor type\n"),
 339                              this->name_.c_str ()),
 340                             0);
 341         }
 342
 343       ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, 0.0);
 344
 345       return this->data_.last_;
 346     }
 347
 348     Monitor_Control_Types::NameList
 349     Monitor_Base::get_list (void) const
 350     {
 351       Monitor_Control_Types::NameList retval;
 352
 353       if (this->data_.type_ != Monitor_Control_Types::MC_LIST)
 354         {
 355           ACE_ERROR ((LM_ERROR,
 356                       ACE_TEXT ("get_list: %s is not a ")
 357                       ACE_TEXT ("list monitor type\n"),
 358                       this->name_.c_str ()));
 359
 360           return retval;
 361         }
 362
 363       ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, this->mutex_, retval);
 364
 365       for (size_t i = 0UL; i < this->data_.index_; ++i)
 366         {
 367           retval.push_back (this->data_.list_[i]);
 368         }
 369
 370       return retval;
 371     }
 372
 373     void
 374     Monitor_Base::clear_i (void)
 375     {
 376       if (this->data_.type_ == Monitor_Control_Types::MC_LIST)
 377         {
 378           for (size_t i = 0UL; i < this->data_.index_; ++i)
 379             {
 380               ACE::strdelete (this->data_.list_[i]);
 381             }
 382
 383           this->data_.list_.max_size (0UL);
 384         }
 385
 386       this->data_.value_ = 0.0;
 387       this->data_.timestamp_ = ACE_Time_Value::zero;
 388       this->data_.index_ = 0UL;
 389       this->data_.minimum_set_ = false;
 390       this->data_.minimum_ = 0.0;
 391       this->data_.maximum_ = 0.0;
 392       this->data_.sum_ = 0.0;
 393       this->data_.sum_of_squares_ = 0.0;
 394       this->data_.last_ = 0.0;
 395     }
 396   }
 397 }
 398
 399 ACE_END_VERSIONED_NAMESPACE_DECL
 400
 401 #endif /* ACE_HAS_MONITOR_FRAMEWORK==1 */
 402