| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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 // A StatsTable is a table of statistics. It can be used across multiple | |
| 6 // processes and threads, maintaining cheap statistics counters without | |
| 7 // locking. | |
| 8 // | |
| 9 // The goal is to make it very cheap and easy for developers to add | |
| 10 // counters to code, without having to build one-off utilities or mechanisms | |
| 11 // to track the counters, and also to allow a single "view" to display | |
| 12 // the contents of all counters. | |
| 13 // | |
| 14 // To achieve this, StatsTable creates a shared memory segment to store | |
| 15 // the data for the counters. Upon creation, it has a specific size | |
| 16 // which governs the maximum number of counters and concurrent | |
| 17 // threads/processes which can use it. | |
| 18 // | |
| 19 | |
| 20 #ifndef BASE_METRICS_STATS_TABLE_H_ | |
| 21 #define BASE_METRICS_STATS_TABLE_H_ | |
| 22 | |
| 23 #include <string> | |
| 24 | |
| 25 #include "base/base_export.h" | |
| 26 #include "base/basictypes.h" | |
| 27 #include "base/containers/hash_tables.h" | |
| 28 #include "base/memory/shared_memory.h" | |
| 29 #include "base/synchronization/lock.h" | |
| 30 #include "base/threading/thread_local_storage.h" | |
| 31 #include "build/build_config.h" | |
| 32 | |
| 33 #if defined(OS_POSIX) | |
| 34 #include "base/file_descriptor_posix.h" | |
| 35 #endif | |
| 36 | |
| 37 namespace base { | |
| 38 | |
| 39 class BASE_EXPORT StatsTable { | |
| 40 public: | |
| 41 // Identifies a StatsTable. We often want to share these between processes. | |
| 42 // | |
| 43 // On Windows, we use a named shared memory segment so the table identifier | |
| 44 // should be a relatively unique string identifying the table to use. An | |
| 45 // empty string can be used to use an anonymous shared memory segment for | |
| 46 // cases where the table does not need to be shared between processes. | |
| 47 // | |
| 48 // Posix does not support named memory so we explicitly share file | |
| 49 // descriptors. On Posix, pass a default-constructed file descriptor if a | |
| 50 // handle doesn't already exist, and a new one will be created. | |
| 51 // | |
| 52 // If a table doesn't already exist with the given identifier, a new one will | |
| 53 // be created with zeroed counters. | |
| 54 #if defined(OS_POSIX) | |
| 55 typedef FileDescriptor TableIdentifier; | |
| 56 #elif defined(OS_WIN) | |
| 57 typedef std::string TableIdentifier; | |
| 58 #endif | |
| 59 | |
| 60 // Create a new StatsTable. | |
| 61 // | |
| 62 // max_threads is the maximum number of threads the table will support. | |
| 63 // If the StatsTable already exists, this number is ignored. | |
| 64 // | |
| 65 // max_counters is the maximum number of counters the table will support. | |
| 66 // If the StatsTable already exists, this number is ignored. | |
| 67 StatsTable(const TableIdentifier& table, | |
| 68 int max_threads, | |
| 69 int max_counters); | |
| 70 | |
| 71 // Destroys the StatsTable. When the last StatsTable is destroyed | |
| 72 // (across all processes), the StatsTable is removed from disk. | |
| 73 ~StatsTable(); | |
| 74 | |
| 75 // For convenience, we create a static table. This is generally | |
| 76 // used automatically by the counters. | |
| 77 static StatsTable* current(); | |
| 78 | |
| 79 // Set the global table for use in this process. | |
| 80 static void set_current(StatsTable* value); | |
| 81 | |
| 82 // Get the slot id for the calling thread. Returns 0 if no | |
| 83 // slot is assigned. | |
| 84 int GetSlot() const; | |
| 85 | |
| 86 // All threads that contribute data to the table must register with the | |
| 87 // table first. This function will set thread local storage for the | |
| 88 // thread containing the location in the table where this thread will | |
| 89 // write its counter data. | |
| 90 // | |
| 91 // name is just a debugging tag to label the thread, and it does not | |
| 92 // need to be unique. It will be truncated to kMaxThreadNameLength-1 | |
| 93 // characters. | |
| 94 // | |
| 95 // On success, returns the slot id for this thread. On failure, | |
| 96 // returns 0. | |
| 97 int RegisterThread(const std::string& name); | |
| 98 | |
| 99 // Returns the number of threads currently registered. This is really not | |
| 100 // useful except for diagnostics and debugging. | |
| 101 int CountThreadsRegistered() const; | |
| 102 | |
| 103 // Find a counter in the StatsTable. | |
| 104 // | |
| 105 // Returns an id for the counter which can be used to call GetLocation(). | |
| 106 // If the counter does not exist, attempts to create a row for the new | |
| 107 // counter. If there is no space in the table for the new counter, | |
| 108 // returns 0. | |
| 109 int FindCounter(const std::string& name); | |
| 110 | |
| 111 // TODO(mbelshe): implement RemoveCounter. | |
| 112 | |
| 113 // Gets the location of a particular value in the table based on | |
| 114 // the counter id and slot id. | |
| 115 int* GetLocation(int counter_id, int slot_id) const; | |
| 116 | |
| 117 // Gets the counter name at a particular row. If the row is empty, | |
| 118 // returns NULL. | |
| 119 const char* GetRowName(int index) const; | |
| 120 | |
| 121 // Gets the sum of the values for a particular row. | |
| 122 int GetRowValue(int index) const; | |
| 123 | |
| 124 // Gets the sum of the values for a particular row for a given pid. | |
| 125 int GetRowValue(int index, int pid) const; | |
| 126 | |
| 127 // Gets the sum of the values for a particular counter. If the counter | |
| 128 // does not exist, creates the counter. | |
| 129 int GetCounterValue(const std::string& name); | |
| 130 | |
| 131 // Gets the sum of the values for a particular counter for a given pid. | |
| 132 // If the counter does not exist, creates the counter. | |
| 133 int GetCounterValue(const std::string& name, int pid); | |
| 134 | |
| 135 // The maxinum number of counters/rows in the table. | |
| 136 int GetMaxCounters() const; | |
| 137 | |
| 138 // The maxinum number of threads/columns in the table. | |
| 139 int GetMaxThreads() const; | |
| 140 | |
| 141 #if defined(OS_POSIX) | |
| 142 // Get the underlying shared memory handle for the table. | |
| 143 base::SharedMemoryHandle GetSharedMemoryHandle() const; | |
| 144 #endif | |
| 145 | |
| 146 // The maximum length (in characters) of a Thread's name including | |
| 147 // null terminator, as stored in the shared memory. | |
| 148 static const int kMaxThreadNameLength = 32; | |
| 149 | |
| 150 // The maximum length (in characters) of a Counter's name including | |
| 151 // null terminator, as stored in the shared memory. | |
| 152 static const int kMaxCounterNameLength = 64; | |
| 153 | |
| 154 // Convenience function to lookup a counter location for a | |
| 155 // counter by name for the calling thread. Will register | |
| 156 // the thread if it is not already registered. | |
| 157 static int* FindLocation(const char *name); | |
| 158 | |
| 159 private: | |
| 160 class Internal; | |
| 161 struct TLSData; | |
| 162 typedef hash_map<std::string, int> CountersMap; | |
| 163 | |
| 164 // Returns the space occupied by a thread in the table. Generally used | |
| 165 // if a thread terminates but the process continues. This function | |
| 166 // does not zero out the thread's counters. | |
| 167 // Cannot be used inside a posix tls destructor. | |
| 168 void UnregisterThread(); | |
| 169 | |
| 170 // This variant expects the tls data to be passed in, so it is safe to | |
| 171 // call from inside a posix tls destructor (see doc for pthread_key_create). | |
| 172 void UnregisterThread(TLSData* tls_data); | |
| 173 | |
| 174 // The SlotReturnFunction is called at thread exit for each thread | |
| 175 // which used the StatsTable. | |
| 176 static void SlotReturnFunction(void* data); | |
| 177 | |
| 178 // Locates a free slot in the table. Returns a number > 0 on success, | |
| 179 // or 0 on failure. The caller must hold the shared_memory lock when | |
| 180 // calling this function. | |
| 181 int FindEmptyThread() const; | |
| 182 | |
| 183 // Locates a counter in the table or finds an empty row. Returns a | |
| 184 // number > 0 on success, or 0 on failure. The caller must hold the | |
| 185 // shared_memory_lock when calling this function. | |
| 186 int FindCounterOrEmptyRow(const std::string& name) const; | |
| 187 | |
| 188 // Internal function to add a counter to the StatsTable. Assumes that | |
| 189 // the counter does not already exist in the table. | |
| 190 // | |
| 191 // name is a unique identifier for this counter, and will be truncated | |
| 192 // to kMaxCounterNameLength-1 characters. | |
| 193 // | |
| 194 // On success, returns the counter_id for the newly added counter. | |
| 195 // On failure, returns 0. | |
| 196 int AddCounter(const std::string& name); | |
| 197 | |
| 198 // Get the TLS data for the calling thread. Returns NULL if none is | |
| 199 // initialized. | |
| 200 TLSData* GetTLSData() const; | |
| 201 | |
| 202 Internal* internal_; | |
| 203 | |
| 204 // The counters_lock_ protects the counters_ hash table. | |
| 205 base::Lock counters_lock_; | |
| 206 | |
| 207 // The counters_ hash map is an in-memory hash of the counters. | |
| 208 // It is used for quick lookup of counters, but is cannot be used | |
| 209 // as a substitute for what is in the shared memory. Even though | |
| 210 // we don't have a counter in our hash table, another process may | |
| 211 // have created it. | |
| 212 CountersMap counters_; | |
| 213 ThreadLocalStorage::Slot tls_index_; | |
| 214 | |
| 215 DISALLOW_COPY_AND_ASSIGN(StatsTable); | |
| 216 }; | |
| 217 | |
| 218 } // namespace base | |
| 219 | |
| 220 #endif // BASE_METRICS_STATS_TABLE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 935333002:
Update from https://crrev.com/316786 (Closed)
Base URL: git@github.com:domokit/mojo.git@master