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