ACE/ace/Monitor_Base.cpp

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