blob: e29aaf244c9d0e95e78b26fc2db761c3f01082c4 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
// 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 "chrome/common/startup_metric_utils.h"
#include "base/hash_tables.h"
#include "base/logging.h"
#include "base/metrics/histogram.h"
#include "base/synchronization/lock.h"
#include "base/sys_info.h"
#include "base/time.h"
namespace {
// Mark as volatile to defensively make sure usage is thread-safe.
// Note that at the time of this writing, access is only on the UI thread.
volatile bool g_non_browser_ui_displayed = false;
const base::Time* MainEntryPointTimeInternal() {
static base::Time main_start_time = base::Time::Now();
return &main_start_time;
}
typedef base::hash_map<std::string,base::TimeDelta> SubsystemStartupTimeHash;
SubsystemStartupTimeHash* GetSubsystemStartupTimeHash() {
static SubsystemStartupTimeHash* slow_startup_time_hash =
new SubsystemStartupTimeHash;
return slow_startup_time_hash;
}
base::Lock* GetSubsystemStartupTimeHashLock() {
static base::Lock* slow_startup_time_hash_lock = new base::Lock;
return slow_startup_time_hash_lock;
}
bool g_main_entry_time_was_recorded = false;
} // namespace
namespace startup_metric_utils {
bool WasNonBrowserUIDisplayed() {
return g_non_browser_ui_displayed;
}
void SetNonBrowserUIDisplayed() {
g_non_browser_ui_displayed = true;
}
void RecordMainEntryPointTime() {
DCHECK(!g_main_entry_time_was_recorded);
g_main_entry_time_was_recorded = true;
MainEntryPointTimeInternal();
}
// Return the time recorded by RecordMainEntryPointTime().
const base::Time MainEntryStartTime() {
DCHECK(g_main_entry_time_was_recorded);
return *MainEntryPointTimeInternal();
}
void OnBrowserStartupComplete() {
// Bail if uptime < 7 minutes, to filter out cases where Chrome may have been
// autostarted and the machine is under io pressure.
const int64 kSevenMinutesInMilliseconds =
base::TimeDelta::FromMinutes(7).InMilliseconds();
if (base::SysInfo::Uptime() < kSevenMinutesInMilliseconds)
return;
const base::TimeDelta kStartupTimeMin(base::TimeDelta::FromMilliseconds(1));
const base::TimeDelta kStartupTimeMax(base::TimeDelta::FromMinutes(5));
static const size_t kStartupTimeBuckets(100);
// The Startup.BrowserMessageLoopStartTime histogram recorded in
// chrome_browser_main.cc exhibits instability in the field which limits its
// usefulness in all scenarios except when we have a very large sample size.
// Attempt to mitigate this with a new metric:
// * Measure time from main entry rather than the OS' notion of process start
// time.
// * Only measure launches that occur 7 minutes after boot to try to avoid
// cases where Chrome is auto-started and IO is heavily loaded.
base::TimeDelta startup_time_from_main_entry =
base::Time::Now() - MainEntryStartTime();
UMA_HISTOGRAM_LONG_TIMES(
"Startup.BrowserMessageLoopStartTimeFromMainEntry",
startup_time_from_main_entry);
// Record histograms for the subsystem times for startups > 10 seconds.
const base::TimeDelta kTenSeconds = base::TimeDelta::FromSeconds(10);
if (startup_time_from_main_entry < kTenSeconds)
return;
{
base::AutoLock locker(*GetSubsystemStartupTimeHashLock());
SubsystemStartupTimeHash* time_hash = GetSubsystemStartupTimeHash();
for (SubsystemStartupTimeHash::iterator i = time_hash->begin();
i != time_hash->end();
++i) {
const std::string histogram_name = i->first;
base::Histogram* counter = base::Histogram::FactoryTimeGet(
histogram_name,
kStartupTimeMin,
kStartupTimeMax,
kStartupTimeBuckets,
base::Histogram::kUmaTargetedHistogramFlag);
counter->AddTime(i->second);
}
}
}
ScopedSlowStartupUMA::~ScopedSlowStartupUMA() {
base::AutoLock locker(*GetSubsystemStartupTimeHashLock());
(*GetSubsystemStartupTimeHash())[histogram_name_] =
base::TimeTicks::Now() - start_time_;
}
} // namespace startup_metric_utils
|
