ACE/ace/Metrics_Cache_T.cpp

   1 #ifndef ACE_METRICS_CACHE_CPP
   2 #define ACE_METRICS_CACHE_CPP
   3
   4 //#define ACE_BUILD_DLL
   5
   6 #include "ace/Metrics_Cache_T.h"
   7
   8 #if defined (ACE_COMPILE_TIMEPROBES)
   9
  10 #include "ace/Metrics_Cache.h"
  11
  12 #if !defined (__ACE_INLINE__)
  13 #include "ace/Metrics_Cache_T.inl"
  14 #endif /* __ACE_INLINE__ */
  15
  16 /// Const strings for timeprobe event type descriptions.
  17 static const char * event_description_strings [] =
  18 {
  19   "start",
  20   "stop",
  21   "suspend",
  22   "resume"
  23 };
  24
  25 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  26
  27 /////////////////////////////////
  28 // class ACE_Metrics_Timeprobe //
  29 /////////////////////////////////
  30
  31 template <class ACE_LOCK, class ALLOCATOR>
  32 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::ACE_Metrics_Timeprobe (u_int id,
  33                                                                    const char *name,
  34                                                                    u_long size)
  35   :
  36     ACE_Timeprobe<ACE_LOCK> (size),
  37     id_ (id),
  38     name_ (0)
  39 {
  40   if (name == 0)
  41     {
  42       name = "";
  43     }
  44
  45   char * name_tmp = 0;
  46   ACE_NEW_MALLOC_ARRAY (name_tmp,
  47                         (char *) this->allocator ()->malloc (ACE_OS::strlen(name)+1),
  48                         char,
  49                         ACE_OS::strlen(name)+1);
  50   ACE_OS::memcpy (name_tmp, name, ACE_OS::strlen (name)+1);
  51   name_ = name_tmp;
  52
  53   this->event_descriptions (event_description_strings,
  54                             sizeof(event_description_strings)/sizeof(const char *));
  55 }
  56
  57 template <class ACE_LOCK, class ALLOCATOR>
  58 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::
  59 ACE_Metrics_Timeprobe (ALLOCATOR *alloc,
  60                        u_int id,
  61                        const char *name,
  62                        u_long size)
  63   : ACE_Timeprobe_Ex<ACE_LOCK, ALLOCATOR> (size),
  64     id_ (id),
  65     name_ (0)
  66 {
  67   if (name == 0)
  68     {
  69       name = "";
  70     }
  71
  72   char * name_tmp = 0;
  73   ACE_NEW_MALLOC_ARRAY (name_tmp,
  74                         (char *) alloc->malloc(ACE_OS::strlen(name)+1),
  75                         char,
  76                         ACE_OS::strlen(name)+1);
  77   ACE_OS::memcpy (name_tmp, name, ACE_OS::strlen (name)+1);
  78   name_ = name_tmp;
  79
  80   this->event_descriptions (event_description_strings,
  81                             sizeof(event_description_strings)/sizeof(const char *));
  82 }
  83
  84 template <class ACE_LOCK, class ALLOCATOR>
  85 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::~ACE_Metrics_Timeprobe ()
  86 {
  87    if (name_)
  88     {
  89          this->allocator ()->free ((void*) name_);
  90     }
  91 }
  92
  93
  94 // Returns true if a timeprobe matches the passed id.
  95
  96 template <class ACE_LOCK, class ALLOCATOR>
  97 int
  98 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::is_event (const ACE_Metrics_Timeprobe<ACE_LOCK,
  99                                                       ALLOCATOR>::
 100                                                       ACE_METRICS_TIMEPROBE_DATA_TYPE &t,
 101                                                       ACE_Metrics_Timeprobe<ACE_LOCK,
 102                                                       ALLOCATOR>::
 103                                                       event_id id)
 104 {
 105   return (t.event_.event_number_ ==  (u_long) id) ? 1 : 0;
 106 }
 107
 108 template <class ACE_LOCK, class ALLOCATOR>
 109 const char *
 110 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::probe_name (void)
 111 {
 112    return name_;
 113 }
 114
 115 template <class ACE_LOCK, class ALLOCATOR>
 116 void
 117 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::probe_name (char * name)
 118 {
 119   char * name_tmp = 0;
 120   ACE_NEW_MALLOC_ARRAY (name_tmp,
 121                         (char *) this->allocator ()->malloc (ACE_OS::strlen(name)+1),
 122                         char,
 123                         ACE_OS::strlen(name)+1);
 124   ACE_OS::memcpy (name_tmp, name, ACE_OS::strlen (name)+1);
 125
 126   if (name_)
 127   {
 128      this->allocator ()->free (name_);
 129   }
 130
 131   name_ = name_tmp;
 132 }
 133
 134 template <class ACE_LOCK, class ALLOCATOR>
 135 u_int
 136 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::probe_id (void)
 137 {
 138   return id_;
 139 }
 140
 141
 142 template <class ACE_LOCK, class ALLOCATOR>
 143 void
 144 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::probe_id (u_int id)
 145 {
 146   id_ = id;
 147 }
 148
 149
 150 // Flush the ACE metrics timeprobe into shared memory.
 151
 152 template <class ACE_LOCK, class ALLOCATOR> void
 153 ACE_Metrics_Timeprobe<ACE_LOCK, ALLOCATOR>::
 154 flush_ACE_Metrics_Timeprobe ()
 155 {
 156 }
 157
 158
 159 /////////////////////////////
 160 // Class ACE_Metrics_Cache //
 161 /////////////////////////////
 162
 163
 164 // Constructor.
 165
 166 template <class ACE_LOCK, class ALLOCATOR>
 167 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::
 168 ACE_Metrics_Cache (u_long table_size,
 169                    u_long,
 170                    ALLOCATOR *alloc)
 171   : probe_set_size_ (0),
 172     enqueue_names_ (0),
 173     dequeue_names_ (0),
 174     consumer_index_ (0),
 175     supplier_index_ (1),
 176     table_size_ (table_size),
 177     interval_start_ (ACE_Time_Value::zero),
 178     interval_end_ (ACE_Time_Value::zero),
 179     interval_initialized_ (0),
 180     metrics_enabled_(1),
 181     allocator_ (alloc)
 182 {
 183   // Initialize probe and count arrays.
 184
 185   // Ensure that the high res timer global scale factor
 186   // is set before any of its static methods are used
 187   ACE_High_Res_Timer::global_scale_factor ();
 188
 189   enqueue_count_ [0] = 0;
 190   enqueue_count_ [1] = 0;
 191   dequeue_count_ [0] = 0;
 192   dequeue_count_ [1] = 0;
 193   enqueue_probes_ [0] = 0;
 194   enqueue_probes_ [1] = 0;
 195   dequeue_probes_ [0] = 0;
 196   dequeue_probes_ [1] = 0;
 197 }
 198
 199 // Destructor.
 200
 201 template <class ACE_LOCK, class ALLOCATOR>
 202 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::~ACE_Metrics_Cache ()
 203 {
 204 }
 205
 206 // Obtain an allocator pointer correctly thunked for the current
 207 // address space.  If there is no allocator stored in the instance,
 208 // the singleton allocator in the current process is used.
 209
 210 template <class ACE_LOCK, class ALLOCATOR> ALLOCATOR *
 211 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::allocator (void)
 212 {
 213   ALLOCATOR * alloc = allocator_;
 214   return alloc
 215          ? alloc
 216          : ACE_Singleton<ALLOCATOR, ACE_LOCK>::instance ();
 217 }
 218
 219
 220 // Flush the ACE metrics cache into shared memory.
 221
 222 template <class ACE_LOCK, class ALLOCATOR> void
 223 ACE_Metrics_Cache<ACE_LOCK, ALLOCATOR>::
 224 flush_ACE_Metrics_Cache ()
 225 {
 226 }
 227
 228 ACE_END_VERSIONED_NAMESPACE_DECL
 229
 230 #endif /* defined (ACE_COMPILE_TIMEPROBES) */
 231
 232 #endif /* ACE_METRICS_CACHE_CPP */