// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "base/metrics/statistics_recorder.h" #include "base/at_exit.h" #include "base/debug/leak_annotations.h" #include "base/json/string_escape.h" #include "base/logging.h" #include "base/memory/scoped_ptr.h" #include "base/metrics/histogram.h" #include "base/strings/stringprintf.h" #include "base/synchronization/lock.h" #include "base/values.h" using std::list; using std::string; namespace { // Initialize histogram statistics gathering system. base::LazyInstance::Leaky g_statistics_recorder_ = LAZY_INSTANCE_INITIALIZER; } // namespace namespace base { // static void StatisticsRecorder::Initialize() { // Ensure that an instance of the StatisticsRecorder object is created. g_statistics_recorder_.Get(); } // static bool StatisticsRecorder::IsActive() { if (lock_ == NULL) return false; base::AutoLock auto_lock(*lock_); return NULL != histograms_; } // static HistogramBase* StatisticsRecorder::RegisterOrDeleteDuplicate( HistogramBase* histogram) { // As per crbug.com/79322 the histograms are intentionally leaked, so we need // to annotate them. Because ANNOTATE_LEAKING_OBJECT_PTR may be used only once // for an object, the duplicates should not be annotated. // Callers are responsible for not calling RegisterOrDeleteDuplicate(ptr) // twice if (lock_ == NULL) || (!histograms_). if (lock_ == NULL) { ANNOTATE_LEAKING_OBJECT_PTR(histogram); // see crbug.com/79322 return histogram; } HistogramBase* histogram_to_delete = NULL; HistogramBase* histogram_to_return = NULL; { base::AutoLock auto_lock(*lock_); if (histograms_ == NULL) { histogram_to_return = histogram; } else { const string& name = histogram->histogram_name(); HistogramMap::iterator it = histograms_->find(name); if (histograms_->end() == it) { (*histograms_)[name] = histogram; ANNOTATE_LEAKING_OBJECT_PTR(histogram); // see crbug.com/79322 histogram_to_return = histogram; } else if (histogram == it->second) { // The histogram was registered before. histogram_to_return = histogram; } else { // We already have one histogram with this name. histogram_to_return = it->second; histogram_to_delete = histogram; } } } delete histogram_to_delete; return histogram_to_return; } // static const BucketRanges* StatisticsRecorder::RegisterOrDeleteDuplicateRanges( const BucketRanges* ranges) { DCHECK(ranges->HasValidChecksum()); scoped_ptr ranges_deleter; if (lock_ == NULL) { ANNOTATE_LEAKING_OBJECT_PTR(ranges); return ranges; } base::AutoLock auto_lock(*lock_); if (ranges_ == NULL) { ANNOTATE_LEAKING_OBJECT_PTR(ranges); return ranges; } list* checksum_matching_list; RangesMap::iterator ranges_it = ranges_->find(ranges->checksum()); if (ranges_->end() == ranges_it) { // Add a new matching list to map. checksum_matching_list = new list(); ANNOTATE_LEAKING_OBJECT_PTR(checksum_matching_list); (*ranges_)[ranges->checksum()] = checksum_matching_list; } else { checksum_matching_list = ranges_it->second; } list::iterator checksum_matching_list_it; for (checksum_matching_list_it = checksum_matching_list->begin(); checksum_matching_list_it != checksum_matching_list->end(); ++checksum_matching_list_it) { const BucketRanges* existing_ranges = *checksum_matching_list_it; if (existing_ranges->Equals(ranges)) { if (existing_ranges == ranges) { return ranges; } else { ranges_deleter.reset(ranges); return existing_ranges; } } } // We haven't found a BucketRanges which has the same ranges. Register the // new BucketRanges. checksum_matching_list->push_front(ranges); return ranges; } // static void StatisticsRecorder::WriteHTMLGraph(const std::string& query, std::string* output) { if (!IsActive()) return; Histograms snapshot; GetSnapshot(query, &snapshot); for (Histograms::iterator it = snapshot.begin(); it != snapshot.end(); ++it) { (*it)->WriteHTMLGraph(output); output->append("


"); } } // static void StatisticsRecorder::WriteGraph(const std::string& query, std::string* output) { if (!IsActive()) return; if (query.length()) StringAppendF(output, "Collections of histograms for %s\n", query.c_str()); else output->append("Collections of all histograms\n"); Histograms snapshot; GetSnapshot(query, &snapshot); for (Histograms::iterator it = snapshot.begin(); it != snapshot.end(); ++it) { (*it)->WriteAscii(output); output->append("\n"); } } // static std::string StatisticsRecorder::ToJSON(const std::string& query) { if (!IsActive()) return std::string(); std::string output("{"); if (!query.empty()) { output += "\"query\":"; EscapeJSONString(query, true, &output); output += ","; } Histograms snapshot; GetSnapshot(query, &snapshot); output += "\"histograms\":["; bool first_histogram = true; for (Histograms::const_iterator it = snapshot.begin(); it != snapshot.end(); ++it) { if (first_histogram) first_histogram = false; else output += ","; std::string json; (*it)->WriteJSON(&json); output += json; } output += "]}"; return output; } // static void StatisticsRecorder::GetHistograms(Histograms* output) { if (lock_ == NULL) return; base::AutoLock auto_lock(*lock_); if (histograms_ == NULL) return; for (HistogramMap::iterator it = histograms_->begin(); histograms_->end() != it; ++it) { DCHECK_EQ(it->first, it->second->histogram_name()); output->push_back(it->second); } } // static void StatisticsRecorder::GetBucketRanges( std::vector* output) { if (lock_ == NULL) return; base::AutoLock auto_lock(*lock_); if (ranges_ == NULL) return; for (RangesMap::iterator it = ranges_->begin(); ranges_->end() != it; ++it) { list* ranges_list = it->second; list::iterator ranges_list_it; for (ranges_list_it = ranges_list->begin(); ranges_list_it != ranges_list->end(); ++ranges_list_it) { output->push_back(*ranges_list_it); } } } // static HistogramBase* StatisticsRecorder::FindHistogram(const std::string& name) { if (lock_ == NULL) return NULL; base::AutoLock auto_lock(*lock_); if (histograms_ == NULL) return NULL; HistogramMap::iterator it = histograms_->find(name); if (histograms_->end() == it) return NULL; return it->second; } // private static void StatisticsRecorder::GetSnapshot(const std::string& query, Histograms* snapshot) { if (lock_ == NULL) return; base::AutoLock auto_lock(*lock_); if (histograms_ == NULL) return; for (HistogramMap::iterator it = histograms_->begin(); histograms_->end() != it; ++it) { if (it->first.find(query) != std::string::npos) snapshot->push_back(it->second); } } // This singleton instance should be started during the single threaded portion // of main(), and hence it is not thread safe. It initializes globals to // provide support for all future calls. StatisticsRecorder::StatisticsRecorder() { DCHECK(!histograms_); if (lock_ == NULL) { // This will leak on purpose. It's the only way to make sure we won't race // against the static uninitialization of the module while one of our // static methods relying on the lock get called at an inappropriate time // during the termination phase. Since it's a static data member, we will // leak one per process, which would be similar to the instance allocated // during static initialization and released only on process termination. lock_ = new base::Lock; } base::AutoLock auto_lock(*lock_); histograms_ = new HistogramMap; ranges_ = new RangesMap; if (VLOG_IS_ON(1)) AtExitManager::RegisterCallback(&DumpHistogramsToVlog, this); } // static void StatisticsRecorder::DumpHistogramsToVlog(void* instance) { DCHECK(VLOG_IS_ON(1)); StatisticsRecorder* me = reinterpret_cast(instance); string output; me->WriteGraph(std::string(), &output); VLOG(1) << output; } StatisticsRecorder::~StatisticsRecorder() { DCHECK(histograms_ && ranges_ && lock_); // Clean up. scoped_ptr histograms_deleter; scoped_ptr ranges_deleter; // We don't delete lock_ on purpose to avoid having to properly protect // against it going away after we checked for NULL in the static methods. { base::AutoLock auto_lock(*lock_); histograms_deleter.reset(histograms_); ranges_deleter.reset(ranges_); histograms_ = NULL; ranges_ = NULL; } // We are going to leak the histograms and the ranges. } // static StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL; // static StatisticsRecorder::RangesMap* StatisticsRecorder::ranges_ = NULL; // static base::Lock* StatisticsRecorder::lock_ = NULL; } // namespace base