dbus/dbus_statistics.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "dbus/dbus_statistics.h"
   6
   7 #include <set>
   8
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/stl_util.h"
  12 #include "base/stringprintf.h"
  13 #include "base/threading/platform_thread.h"
  14 #include "base/time.h"
  15
  16 namespace dbus {
  17
  18 namespace {
  19
  20 // Used to store dbus statistics sorted alphabetically by service, interface,
  21 // then method (using std::string <).
  22 struct Stat {
  23   Stat(const std::string& service,
  24        const std::string& interface,
  25        const std::string& method)
  26       : service(service),
  27         interface(interface),
  28         method(method),
  29         sent_method_calls(0),
  30         received_signals(0),
  31         sent_blocking_method_calls(0) {
  32   }
  33   std::string service;
  34   std::string interface;
  35   std::string method;
  36   int sent_method_calls;
  37   int received_signals;
  38   int sent_blocking_method_calls;
  39
  40   bool Compare(const Stat& other) const {
  41     if (service != other.service)
  42       return service < other.service;
  43     if (interface != other.interface)
  44       return interface < other.interface;
  45     return method < other.method;
  46   }
  47
  48   struct PtrCompare {
  49     bool operator()(Stat* lhs, Stat* rhs) const {
  50       DCHECK(lhs && rhs);
  51       return lhs->Compare(*rhs);
  52     }
  53   };
  54 };
  55
  56 typedef std::set<Stat*, Stat::PtrCompare> StatSet;
  57
  58 //------------------------------------------------------------------------------
  59 // DBusStatistics
  60
  61 // Simple class for gathering DBus usage statistics.
  62 class DBusStatistics {
  63  public:
  64   DBusStatistics()
  65       : start_time_(base::Time::Now()),
  66         origin_thread_id_(base::PlatformThread::CurrentId()) {
  67   }
  68
  69   ~DBusStatistics() {
  70     DCHECK_EQ(origin_thread_id_, base::PlatformThread::CurrentId());
  71     STLDeleteContainerPointers(stats_.begin(), stats_.end());
  72   }
  73
  74   // Enum to specify which field in Stat to increment in AddStat
  75   enum StatType {
  76     TYPE_SENT_METHOD_CALLS,
  77     TYPE_RECEIVED_SIGNALS,
  78     TYPE_SENT_BLOCKING_METHOD_CALLS
  79   };
  80
  81   // Add a call to |method| for |interface|. See also MethodCall in message.h.
  82   void AddStat(const std::string& service,
  83                const std::string& interface,
  84                const std::string& method,
  85                StatType type) {
  86     if (base::PlatformThread::CurrentId() != origin_thread_id_) {
  87       DLOG(WARNING) << "Ignoring DBusStatistics::AddStat call from thread: "
  88                     << base::PlatformThread::CurrentId();
  89       return;
  90     }
  91     Stat* stat = GetStat(service, interface, method, true);
  92     DCHECK(stat);
  93     if (type == TYPE_SENT_METHOD_CALLS)
  94       ++stat->sent_method_calls;
  95     else if (type == TYPE_RECEIVED_SIGNALS)
  96       ++stat->received_signals;
  97     else if (type == TYPE_SENT_BLOCKING_METHOD_CALLS)
  98       ++stat->sent_blocking_method_calls;
  99     else
 100       NOTREACHED();
 101   }
 102
 103   // Look up the Stat entry in |stats_|. If |add_stat| is true, add a new entry
 104   // if one does not already exist.
 105   Stat* GetStat(const std::string& service,
 106                 const std::string& interface,
 107                 const std::string& method,
 108                 bool add_stat) {
 109     DCHECK_EQ(origin_thread_id_, base::PlatformThread::CurrentId());
 110     scoped_ptr<Stat> stat(new Stat(service, interface, method));
 111     StatSet::iterator found = stats_.find(stat.get());
 112     if (found != stats_.end())
 113       return *found;
 114     if (!add_stat)
 115       return NULL;
 116     found = stats_.insert(stat.release()).first;
 117     return *found;
 118   }
 119
 120   StatSet& stats() { return stats_; }
 121   base::Time start_time() { return start_time_; }
 122
 123  private:
 124   StatSet stats_;
 125   base::Time start_time_;
 126   base::PlatformThreadId origin_thread_id_;
 127
 128   DISALLOW_COPY_AND_ASSIGN(DBusStatistics);
 129 };
 130
 131 DBusStatistics* g_dbus_statistics = NULL;
 132
 133 }  // namespace
 134
 135 //------------------------------------------------------------------------------
 136
 137 namespace statistics {
 138
 139 void Initialize() {
 140   if (g_dbus_statistics)
 141     delete g_dbus_statistics;  // reset statistics
 142   g_dbus_statistics = new DBusStatistics();
 143 }
 144
 145 void Shutdown() {
 146   delete g_dbus_statistics;
 147   g_dbus_statistics = NULL;
 148 }
 149
 150 void AddSentMethodCall(const std::string& service,
 151                        const std::string& interface,
 152                        const std::string& method) {
 153   if (!g_dbus_statistics)
 154     return;
 155   g_dbus_statistics->AddStat(
 156       service, interface, method, DBusStatistics::TYPE_SENT_METHOD_CALLS);
 157 }
 158
 159 void AddReceivedSignal(const std::string& service,
 160                        const std::string& interface,
 161                        const std::string& method) {
 162   if (!g_dbus_statistics)
 163     return;
 164   g_dbus_statistics->AddStat(
 165       service, interface, method, DBusStatistics::TYPE_RECEIVED_SIGNALS);
 166 }
 167
 168 void AddBlockingSentMethodCall(const std::string& service,
 169                                const std::string& interface,
 170                                const std::string& method) {
 171   if (!g_dbus_statistics)
 172     return;
 173   g_dbus_statistics->AddStat(
 174       service, interface, method,
 175       DBusStatistics::TYPE_SENT_BLOCKING_METHOD_CALLS);
 176 }
 177
 178 // NOTE: If the output format is changed, be certain to change the test
 179 // expectations as well.
 180 std::string GetAsString(ShowInString show, FormatString format) {
 181   if (!g_dbus_statistics)
 182     return "DBusStatistics not initialized.";
 183
 184   const StatSet& stats = g_dbus_statistics->stats();
 185   if (stats.empty())
 186     return "No DBus calls.";
 187
 188   base::TimeDelta dtime = base::Time::Now() - g_dbus_statistics->start_time();
 189   int dminutes = dtime.InMinutes();
 190   dminutes = std::max(dminutes, 1);
 191
 192   std::string result;
 193   int sent = 0, received = 0, sent_blocking = 0;
 194   // Stats are stored in order by service, then interface, then method.
 195   for (StatSet::const_iterator iter = stats.begin(); iter != stats.end(); ) {
 196     StatSet::const_iterator cur_iter = iter;
 197     StatSet::const_iterator next_iter = ++iter;
 198     const Stat* stat = *cur_iter;
 199     sent += stat->sent_method_calls;
 200     received += stat->received_signals;
 201     sent_blocking += stat->sent_blocking_method_calls;
 202     // If this is not the last stat, and if the next stat matches the current
 203     // stat, continue.
 204     if (next_iter != stats.end() &&
 205         (*next_iter)->service == stat->service &&
 206         (show < SHOW_INTERFACE || (*next_iter)->interface == stat->interface) &&
 207         (show < SHOW_METHOD || (*next_iter)->method == stat->method))
 208       continue;
 209
 210     if (!sent && !received && !sent_blocking)
 211         continue;  // No stats collected for this line, skip it and continue.
 212
 213     // Add a line to the result and clear the counts.
 214     std::string line;
 215     if (show == SHOW_SERVICE) {
 216       line += stat->service;
 217     } else {
 218       // The interface usually includes the service so don't show both.
 219       line += stat->interface;
 220       if (show >= SHOW_METHOD)
 221         line += "." + stat->method;
 222     }
 223     line += base::StringPrintf(":");
 224     if (sent_blocking) {
 225       line += base::StringPrintf(" Sent (BLOCKING):");
 226       if (format == FORMAT_TOTALS)
 227         line += base::StringPrintf(" %d", sent_blocking);
 228       else if (format == FORMAT_PER_MINUTE)
 229         line += base::StringPrintf(" %d/min", sent_blocking / dminutes);
 230       else if (format == FORMAT_ALL)
 231         line += base::StringPrintf(" %d (%d/min)",
 232                                    sent_blocking, sent_blocking / dminutes);
 233     }
 234     if (sent) {
 235       line += base::StringPrintf(" Sent:");
 236       if (format == FORMAT_TOTALS)
 237         line += base::StringPrintf(" %d", sent);
 238       else if (format == FORMAT_PER_MINUTE)
 239         line += base::StringPrintf(" %d/min", sent / dminutes);
 240       else if (format == FORMAT_ALL)
 241         line += base::StringPrintf(" %d (%d/min)", sent, sent / dminutes);
 242     }
 243     if (received) {
 244       line += base::StringPrintf(" Received:");
 245       if (format == FORMAT_TOTALS)
 246         line += base::StringPrintf(" %d", received);
 247       else if (format == FORMAT_PER_MINUTE)
 248         line += base::StringPrintf(" %d/min", received / dminutes);
 249       else if (format == FORMAT_ALL)
 250         line += base::StringPrintf(
 251             " %d (%d/min)", received, received / dminutes);
 252     }
 253     result += line + "\n";
 254     sent = 0;
 255     sent_blocking = 0;
 256     received = 0;
 257   }
 258   return result;
 259 }
 260
 261 namespace testing {
 262
 263 bool GetCalls(const std::string& service,
 264               const std::string& interface,
 265               const std::string& method,
 266               int* sent,
 267               int* received,
 268               int* blocking) {
 269   if (!g_dbus_statistics)
 270     return false;
 271   Stat* stat = g_dbus_statistics->GetStat(service, interface, method, false);
 272   if (!stat)
 273     return false;
 274   *sent = stat->sent_method_calls;
 275   *received = stat->received_signals;
 276   *blocking = stat->sent_blocking_method_calls;
 277   return true;
 278 }
 279
 280 }  // namespace testing
 281
 282 }  // namespace statistics
 283 }  // namespace dbus