Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(153)

Unified Diff: chrome/browser/net/load_time_stats.cc

Issue 10834313: Add histograms for network activity, and total/cumulative (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: Created 8 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/net/load_time_stats.h ('k') | chrome/browser/profiles/off_the_record_profile_io_data.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/net/load_time_stats.cc
===================================================================
--- chrome/browser/net/load_time_stats.cc (revision 150909)
+++ chrome/browser/net/load_time_stats.cc (working copy)
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "chrome/browser/net/cache_stats.h"
+#include "chrome/browser/net/load_time_stats.h"
#include "base/metrics/histogram.h"
#include "base/stl_util.h"
@@ -22,6 +22,7 @@
using content::BrowserThread;
using content::RenderViewHost;
using content::ResourceRequestInfo;
+using std::string;
#if defined(COMPILER_GCC)
@@ -47,13 +48,13 @@
return info->GetAssociatedRenderView(process_id, route_id);
}
-void CallCacheStatsTabEventOnIOThread(
+void CallLoadTimeStatsTabEventOnIOThread(
std::pair<int, int> render_view_id,
- chrome_browser_net::CacheStats::TabEvent event,
+ chrome_browser_net::LoadTimeStats::TabEvent event,
IOThread* io_thread) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
if (io_thread)
- io_thread->globals()->cache_stats->OnTabEvent(render_view_id, event);
+ io_thread->globals()->load_time_stats->OnTabEvent(render_view_id, event);
}
// Times after a load has started at which stats are collected.
@@ -72,6 +73,30 @@
static int kTabLoadStatsAutoCleanupTimeoutSeconds = 30;
+const char* kRequestStatusNames[] = {
+ "CacheWait",
+ "NetworkWait",
+ "Active",
+ "None",
+ "Max"
+};
+
+COMPILE_ASSERT(arraysize(kRequestStatusNames) ==
+ chrome_browser_net::LoadTimeStats::REQUEST_STATUS_MAX + 1,
+ LoadTimeStats_RequestStatus_names_mismatch);
+
+const char* kHistogramTypeNames[] = {
+ "FinalAggregate",
+ "FinalCumulativePercentage",
+ "IntermediateAggregate",
+ "IntermediateCumulativePercentage",
+ "Max"
+};
+
+COMPILE_ASSERT(arraysize(kHistogramTypeNames) ==
+ chrome_browser_net::LoadTimeStats::HISTOGRAM_MAX + 1,
+ LoadTimeStats_HistogramType_names_mismatch);
+
} // namespace
namespace chrome_browser_net {
@@ -79,49 +104,106 @@
// Helper struct keeping stats about the page load progress & cache usage
// stats during the pageload so far for a given RenderView, identified
// by a pair of process id and route id.
-struct CacheStats::TabLoadStats {
- TabLoadStats(std::pair<int, int> render_view_id, CacheStats* owner)
- : render_view_id(render_view_id),
- num_active(0),
- spinner_started(false),
- next_timer_index(0),
- timer(false, false) {
+class LoadTimeStats::TabLoadStats {
+ public:
+ // Stores the time taken by all requests while they have a certain
+ // RequestStatus.
+ class PerStatusStats {
+ public:
+ PerStatusStats() : num_active_(0) {
+ }
+
+ void UpdateTotalTimes() {
+ DCHECK_GE(num_active_, 0);
+ base::TimeTicks now = base::TimeTicks::Now();
+ if (num_active_ > 0) {
+ total_time_ += now - last_update_time_;
+ total_cumulative_time_ +=
+ (now - last_update_time_) * static_cast<int64>(num_active_);
+ }
+ last_update_time_ = now;
+ }
+
+ void ResetTimes() {
+ last_update_time_ = base::TimeTicks::Now();
+ total_time_ = base::TimeDelta();
+ total_cumulative_time_ = base::TimeDelta();
+ }
+
+ void IncrementNumActive() {
+ num_active_++;
+ }
+
+ void DecrementNumActiveIfPositive() {
+ if (num_active_ > 0)
+ num_active_--;
+ }
+
+ int num_active() { return num_active_; }
+ void set_num_active(int num_active) { num_active_ = num_active; }
+ base::TimeDelta total_time() { return total_time_; }
+ base::TimeDelta total_cumulative_time() { return total_cumulative_time_; }
+
+ private:
+ int num_active_;
+ base::TimeTicks last_update_time_;
+ base::TimeDelta total_time_;
+ base::TimeDelta total_cumulative_time_;
+ };
+
+ TabLoadStats(std::pair<int, int> render_view_id, LoadTimeStats* owner)
+ : render_view_id_(render_view_id),
+ spinner_started_(false),
+ next_timer_index_(0),
+ timer_(false, false) {
// Initialize the timer to do an automatic cleanup. If a pageload is
- // started for the TabLoadStats within that timeframe, CacheStats
+ // started for the TabLoadStats within that timeframe, LoadTimeStats
// will start using the timer, thereby cancelling the cleanup.
- // Once CacheStats starts the timer, the object is guaranteed to be
+ // Once LoadTimeStats starts the timer, the object is guaranteed to be
// destroyed eventually, so there is no more need for automatic cleanup at
// that point.
- timer.Start(FROM_HERE,
- base::TimeDelta::FromSeconds(
- kTabLoadStatsAutoCleanupTimeoutSeconds),
- base::Bind(&CacheStats::RemoveTabLoadStats,
- base::Unretained(owner),
- render_view_id));
+ timer_.Start(FROM_HERE,
+ base::TimeDelta::FromSeconds(
+ kTabLoadStatsAutoCleanupTimeoutSeconds),
+ base::Bind(&LoadTimeStats::RemoveTabLoadStats,
+ base::Unretained(owner),
+ render_view_id_));
}
- std::pair<int, int> render_view_id;
- int num_active;
- bool spinner_started;
- base::TimeTicks load_start_time;
- base::TimeTicks cache_start_time;
- base::TimeDelta cache_total_time;
- int next_timer_index;
- base::Timer timer;
- // URLRequest's for which there are outstanding cache transactions.
- base::hash_set<const net::URLRequest*> active_requests;
+ typedef std::pair<int, int> RenderViewId;
+ typedef PerStatusStats PerStatusStatsArray[REQUEST_STATUS_MAX];
+ typedef base::hash_map<const net::URLRequest*, RequestStatus> RequestMap;
+
+ RenderViewId& render_view_id() { return render_view_id_; }
+ PerStatusStatsArray& per_status_stats() { return per_status_stats_; }
+ bool spinner_started() { return spinner_started_; }
+ void set_spinner_started(bool value) { spinner_started_ = value; }
+ base::TimeTicks load_start_time() { return load_start_time_; }
+ int next_timer_index() { return next_timer_index_; }
+ void set_next_timer_index(int index) { next_timer_index_ = index; }
+ base::Timer& timer() { return timer_; }
+ RequestMap& active_requests() { return active_requests_; }
+
+ private:
+ RenderViewId render_view_id_;
+ PerStatusStatsArray per_status_stats_;
+ bool spinner_started_;
+ base::TimeTicks load_start_time_;
+ int next_timer_index_;
+ base::Timer timer_;
+ // Currently active URLRequests.
+ RequestMap active_requests_;
};
-CacheStatsTabHelper::CacheStatsTabHelper(TabContents* tab)
- : content::WebContentsObserver(tab->web_contents()),
- cache_stats_(NULL) {
+LoadTimeStatsTabHelper::LoadTimeStatsTabHelper(TabContents* tab)
+ : content::WebContentsObserver(tab->web_contents()) {
is_otr_profile_ = tab->profile()->IsOffTheRecord();
}
-CacheStatsTabHelper::~CacheStatsTabHelper() {
+LoadTimeStatsTabHelper::~LoadTimeStatsTabHelper() {
}
-void CacheStatsTabHelper::DidStartProvisionalLoadForFrame(
+void LoadTimeStatsTabHelper::DidStartProvisionalLoadForFrame(
int64 frame_id,
bool is_main_frame,
const GURL& validated_url,
@@ -131,15 +213,15 @@
return;
if (!validated_url.SchemeIs("http"))
return;
- NotifyCacheStats(CacheStats::SPINNER_START, render_view_host);
+ NotifyLoadTimeStats(LoadTimeStats::SPINNER_START, render_view_host);
}
-void CacheStatsTabHelper::DidStopLoading(RenderViewHost* render_view_host) {
- NotifyCacheStats(CacheStats::SPINNER_STOP, render_view_host);
+void LoadTimeStatsTabHelper::DidStopLoading(RenderViewHost* render_view_host) {
+ NotifyLoadTimeStats(LoadTimeStats::SPINNER_STOP, render_view_host);
}
-void CacheStatsTabHelper::NotifyCacheStats(
- CacheStats::TabEvent event,
+void LoadTimeStatsTabHelper::NotifyLoadTimeStats(
+ LoadTimeStats::TabEvent event,
RenderViewHost* render_view_host) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
if (is_otr_profile_)
@@ -148,37 +230,42 @@
int route_id = render_view_host->GetRoutingID();
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
- base::Bind(&CallCacheStatsTabEventOnIOThread,
+ base::Bind(&CallLoadTimeStatsTabEventOnIOThread,
std::pair<int, int>(process_id, route_id),
event,
base::Unretained(g_browser_process->io_thread())));
}
-CacheStats::CacheStats() {
- for (int i = 0;
- i < static_cast<int>(arraysize(kStatsCollectionTimesMs));
- i++) {
- final_histograms_.push_back(
- base::LinearHistogram::FactoryGet(
- "CacheStats.FractionCacheUseFinalPLT_" +
- base::IntToString(kStatsCollectionTimesMs[i]),
- 0, 101, 102, base::Histogram::kUmaTargetedHistogramFlag));
- intermediate_histograms_.push_back(
- base::LinearHistogram::FactoryGet(
- "CacheStats.FractionCacheUseIntermediatePLT_" +
- base::IntToString(kStatsCollectionTimesMs[i]),
- 0, 101, 102, base::Histogram::kUmaTargetedHistogramFlag));
+LoadTimeStats::LoadTimeStats() {
+ for (int status = REQUEST_STATUS_CACHE_WAIT;
+ status <= REQUEST_STATUS_ACTIVE;
+ status++) {
+ for (int histogram_type = HISTOGRAM_FINAL_AGGREGATE;
+ histogram_type < HISTOGRAM_MAX;
+ histogram_type++) {
+ for (int i = 0;
+ i < static_cast<int>(arraysize(kStatsCollectionTimesMs));
+ i++) {
+ string histogram_name = string("LoadTimeStats.Fraction_") +
+ string(kRequestStatusNames[status]) + string("_") +
+ string(kHistogramTypeNames[histogram_type]) + string("_") +
+ base::IntToString(kStatsCollectionTimesMs[i]);
+ histograms_[status][histogram_type].push_back(
+ base::LinearHistogram::FactoryGet(
+ histogram_name,
+ 0, 101, 102, base::Histogram::kUmaTargetedHistogramFlag));
+ }
+ DCHECK_EQ(histograms_[status][histogram_type].size(),
+ arraysize(kStatsCollectionTimesMs));
+ }
}
- DCHECK_EQ(final_histograms_.size(), arraysize(kStatsCollectionTimesMs));
- DCHECK_EQ(intermediate_histograms_.size(),
- arraysize(kStatsCollectionTimesMs));
}
-CacheStats::~CacheStats() {
+LoadTimeStats::~LoadTimeStats() {
STLDeleteValues(&tab_load_stats_);
}
-CacheStats::TabLoadStats* CacheStats::GetTabLoadStats(
+LoadTimeStats::TabLoadStats* LoadTimeStats::GetTabLoadStats(
std::pair<int, int> render_view_id) {
TabLoadStatsMap::const_iterator it = tab_load_stats_.find(render_view_id);
if (it != tab_load_stats_.end())
@@ -188,7 +275,7 @@
return new_tab_load_stats;
}
-void CacheStats::RemoveTabLoadStats(std::pair<int, int> render_view_id) {
+void LoadTimeStats::RemoveTabLoadStats(std::pair<int, int> render_view_id) {
TabLoadStatsMap::iterator it = tab_load_stats_.find(render_view_id);
if (it != tab_load_stats_.end()) {
delete it->second;
@@ -196,9 +283,9 @@
}
}
-void CacheStats::OnCacheWaitStateChange(
+void LoadTimeStats::OnRequestWaitStateChange(
const net::URLRequest& request,
- net::NetworkDelegate::CacheWaitState state) {
+ net::NetworkDelegate::RequestWaitState state) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
if (main_request_contexts_.count(request.context()) < 1)
return;
@@ -207,142 +294,176 @@
return;
TabLoadStats* stats =
GetTabLoadStats(std::pair<int, int>(process_id, route_id));
- bool newly_started = false;
- bool newly_finished = false;
+ RequestStatus old_status = REQUEST_STATUS_NONE;
+ if (stats->active_requests().count(&request) > 0)
+ old_status = stats->active_requests()[&request];
+ RequestStatus new_status = REQUEST_STATUS_NONE;
switch (state) {
- case net::NetworkDelegate::CACHE_WAIT_STATE_START:
- DCHECK(stats->active_requests.count(&request) == 0);
- newly_started = true;
- stats->active_requests.insert(&request);
+ case net::NetworkDelegate::REQUEST_WAIT_STATE_CACHE_START:
+ DCHECK(old_status == REQUEST_STATUS_NONE ||
+ old_status == REQUEST_STATUS_ACTIVE);
+ new_status = REQUEST_STATUS_CACHE_WAIT;
break;
- case net::NetworkDelegate::CACHE_WAIT_STATE_FINISH:
- if (stats->active_requests.count(&request) > 0) {
- stats->active_requests.erase(&request);
- newly_finished = true;
- }
+ case net::NetworkDelegate::REQUEST_WAIT_STATE_CACHE_FINISH:
+ DCHECK(old_status == REQUEST_STATUS_NONE ||
+ old_status == REQUEST_STATUS_CACHE_WAIT);
+ new_status = REQUEST_STATUS_ACTIVE;
break;
- case net::NetworkDelegate::CACHE_WAIT_STATE_RESET:
- if (stats->active_requests.count(&request) > 0) {
- stats->active_requests.erase(&request);
- newly_finished = true;
- }
+ case net::NetworkDelegate::REQUEST_WAIT_STATE_NETWORK_START:
+ DCHECK(old_status == REQUEST_STATUS_NONE ||
+ old_status == REQUEST_STATUS_ACTIVE);
+ new_status = REQUEST_STATUS_NETWORK_WAIT;
break;
+ case net::NetworkDelegate::REQUEST_WAIT_STATE_NETWORK_FINISH:
+ DCHECK(old_status == REQUEST_STATUS_NONE ||
+ old_status == REQUEST_STATUS_NETWORK_WAIT);
+ new_status = REQUEST_STATUS_ACTIVE;
+ break;
+ case net::NetworkDelegate::REQUEST_WAIT_STATE_RESET:
+ new_status = REQUEST_STATUS_NONE;
+ break;
}
- DCHECK_GE(stats->num_active, 0);
- if (newly_started) {
- DCHECK(!newly_finished);
- if (stats->num_active == 0) {
- stats->cache_start_time = base::TimeTicks::Now();
- }
- stats->num_active++;
+ if (old_status == new_status)
+ return;
+ if (old_status != REQUEST_STATUS_NONE) {
+ TabLoadStats::PerStatusStats* status_stats =
+ &(stats->per_status_stats()[old_status]);
+ DCHECK_GE(status_stats->num_active(), 0);
+ status_stats->UpdateTotalTimes();
+ status_stats->DecrementNumActiveIfPositive();
+ DCHECK_GE(status_stats->num_active(), 0);
}
- if (newly_finished) {
- DCHECK(!newly_started);
- if (stats->num_active == 1) {
- stats->cache_total_time +=
- base::TimeTicks::Now() - stats->cache_start_time;
- }
- stats->num_active--;
+ if (new_status != REQUEST_STATUS_NONE) {
+ TabLoadStats::PerStatusStats* status_stats =
+ &(stats->per_status_stats()[new_status]);
+ DCHECK_GE(status_stats->num_active(), 0);
+ status_stats->UpdateTotalTimes();
+ status_stats->IncrementNumActive();
+ DCHECK_GE(status_stats->num_active(), 0);
+ stats->active_requests()[&request] = new_status;
+ } else {
+ stats->active_requests().erase(&request);
}
- DCHECK_GE(stats->num_active, 0);
}
-void CacheStats::OnTabEvent(std::pair<int, int> render_view_id,
+void LoadTimeStats::OnTabEvent(std::pair<int, int> render_view_id,
TabEvent event) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
TabLoadStats* stats = GetTabLoadStats(render_view_id);
if (event == SPINNER_START) {
- stats->spinner_started = true;
- stats->cache_total_time = base::TimeDelta();
- stats->cache_start_time = base::TimeTicks::Now();
- stats->load_start_time = base::TimeTicks::Now();
- stats->next_timer_index = 0;
+ stats->set_spinner_started(true);
+ for (int status = REQUEST_STATUS_CACHE_WAIT;
+ status <= REQUEST_STATUS_ACTIVE; status++) {
+ stats->per_status_stats()[status].ResetTimes();
+ }
+ stats->set_next_timer_index(0);
ScheduleTimer(stats);
} else {
DCHECK_EQ(event, SPINNER_STOP);
- if (stats->spinner_started) {
- stats->spinner_started = false;
+ if (stats->spinner_started()) {
+ stats->set_spinner_started(false);
base::TimeDelta load_time =
- base::TimeTicks::Now() - stats->load_start_time;
- if (stats->num_active > 1)
- stats->cache_total_time +=
- base::TimeTicks::Now() - stats->cache_start_time;
- RecordCacheFractionHistogram(load_time, stats->cache_total_time, true,
- stats->next_timer_index);
+ base::TimeTicks::Now() - stats->load_start_time();
+ RecordHistograms(load_time, stats, true);
}
RemoveTabLoadStats(render_view_id);
}
}
-void CacheStats::ScheduleTimer(TabLoadStats* stats) {
- int timer_index = stats->next_timer_index;
+void LoadTimeStats::ScheduleTimer(TabLoadStats* stats) {
+ int timer_index = stats->next_timer_index();
DCHECK(timer_index >= 0 &&
timer_index < static_cast<int>(arraysize(kStatsCollectionTimesMs)));
base::TimeDelta delta =
base::TimeDelta::FromMilliseconds(kStatsCollectionTimesMs[timer_index]);
- delta -= base::TimeTicks::Now() - stats->load_start_time;
+ delta -= base::TimeTicks::Now() - stats->load_start_time();
// If the ScheduleTimer call was delayed significantly, like when one's using
// a debugger, don't try to start the timer with a negative time.
if (delta < base::TimeDelta()) {
- RemoveTabLoadStats(stats->render_view_id);
+ RemoveTabLoadStats(stats->render_view_id());
return;
}
- stats->timer.Start(FROM_HERE,
- delta,
- base::Bind(&CacheStats::TimerCallback,
- base::Unretained(this),
- base::Unretained(stats)));
+ stats->timer().Start(FROM_HERE,
+ delta,
+ base::Bind(&LoadTimeStats::TimerCallback,
+ base::Unretained(this),
+ base::Unretained(stats)));
}
-void CacheStats::TimerCallback(TabLoadStats* stats) {
- DCHECK(stats->spinner_started);
- base::TimeDelta load_time = base::TimeTicks::Now() - stats->load_start_time;
- base::TimeDelta cache_time = stats->cache_total_time;
- if (stats->num_active > 1)
- cache_time += base::TimeTicks::Now() - stats->cache_start_time;
- RecordCacheFractionHistogram(load_time, cache_time, false,
- stats->next_timer_index);
- stats->next_timer_index++;
- if (stats->next_timer_index <
+void LoadTimeStats::TimerCallback(TabLoadStats* stats) {
+ DCHECK(stats->spinner_started());
+ base::TimeDelta load_time = base::TimeTicks::Now() - stats->load_start_time();
+ RecordHistograms(load_time, stats, false);
+ stats->set_next_timer_index(stats->next_timer_index() + 1);
+ if (stats->next_timer_index() <
static_cast<int>(arraysize(kStatsCollectionTimesMs))) {
ScheduleTimer(stats);
} else {
- RemoveTabLoadStats(stats->render_view_id);
+ RemoveTabLoadStats(stats->render_view_id());
}
}
-void CacheStats::RecordCacheFractionHistogram(base::TimeDelta elapsed,
- base::TimeDelta cache_time,
- bool is_load_done,
- int timer_index) {
+void LoadTimeStats::RecordHistograms(base::TimeDelta elapsed,
+ TabLoadStats* stats,
+ bool is_load_done) {
+ int timer_index = stats->next_timer_index();
DCHECK(timer_index >= 0 &&
timer_index < static_cast<int>(arraysize(kStatsCollectionTimesMs)));
if (elapsed.InMilliseconds() <= 0)
return;
- int64 cache_fraction_percentage =
- 100 * cache_time.InMilliseconds() / elapsed.InMilliseconds();
+ base::TimeDelta total_cumulative;
+ for (int status = REQUEST_STATUS_CACHE_WAIT;
+ status <= REQUEST_STATUS_ACTIVE;
+ status++) {
+ total_cumulative +=
+ stats->per_status_stats()[status].total_cumulative_time();
+ }
- DCHECK(cache_fraction_percentage >= 0 && cache_fraction_percentage <= 100);
+ for (int status = REQUEST_STATUS_CACHE_WAIT;
+ status <= REQUEST_STATUS_ACTIVE;
+ status++) {
+ TabLoadStats::PerStatusStats* status_stats =
+ &(stats->per_status_stats()[status]);
- if (is_load_done) {
- final_histograms_[timer_index]->Add(cache_fraction_percentage);
- } else {
- intermediate_histograms_[timer_index]->Add(cache_fraction_percentage);
+ int64 fraction_percentage = 100 *
+ status_stats->total_time().InMilliseconds() / elapsed.InMilliseconds();
+ DCHECK(fraction_percentage >= 0 && fraction_percentage <= 100);
+ if (is_load_done) {
+ histograms_[status][HISTOGRAM_FINAL_AGGREGATE][timer_index]->Add(
+ fraction_percentage);
+ } else {
+ histograms_[status][HISTOGRAM_INTERMEDIATE_AGGREGATE][timer_index]->Add(
+ fraction_percentage);
+ }
+
+ if (total_cumulative.InMilliseconds() > 0) {
+ fraction_percentage = 100 *
+ status_stats->total_cumulative_time().InMilliseconds() /
+ total_cumulative.InMilliseconds();
+ DCHECK(fraction_percentage >= 0 && fraction_percentage <= 100);
+ if (is_load_done) {
+ histograms_[status][HISTOGRAM_FINAL_CUMULATIVE_PERCENTAGE]
+ [timer_index]->Add(fraction_percentage);
+ } else {
+ histograms_[status][HISTOGRAM_INTERMEDIATE_CUMULATIVE_PERCENTAGE]
+ [timer_index]->Add(fraction_percentage);
+ }
+ }
}
}
-void CacheStats::RegisterURLRequestContext(
+void LoadTimeStats::RegisterURLRequestContext(
const net::URLRequestContext* context,
ChromeURLRequestContext::ContextType type) {
if (type == ChromeURLRequestContext::CONTEXT_TYPE_MAIN)
main_request_contexts_.insert(context);
}
-void CacheStats::UnregisterURLRequestContext(
+void LoadTimeStats::UnregisterURLRequestContext(
const net::URLRequestContext* context) {
main_request_contexts_.erase(context);
}
« no previous file with comments | « chrome/browser/net/load_time_stats.h ('k') | chrome/browser/profiles/off_the_record_profile_io_data.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698