--- a/testing/talos/talos/cmdline.py
+++ b/testing/talos/talos/cmdline.py
@@ -75,21 +75,30 @@ def create_parser(mach_interface=False):
add_arg('--rss', action='store_true',
help="Collect RSS counters from pageloader instead of the"
" operating system")
add_arg('--mainthread', action='store_true',
help="Collect mainthread IO data from the browser by setting"
" an environment variable")
add_arg("--mozAfterPaint", action='store_true', dest="tpmozafterpaint",
help="wait for MozAfterPaint event before recording the time")
- add_arg('--spsProfile', action="store_true", dest="sps_profile",
- help="Profile the run and output the results in $MOZ_UPLOAD_DIR")
- add_arg('--spsProfileInterval', dest='sps_profile_interval', type=int,
+ add_arg('--spsProfile', action="store_true", dest="gecko_profile",
+ help="(Deprecated - Use --geckoProfile instead.) Profile the "
+ "run and output the results in $MOZ_UPLOAD_DIR.")
+ add_arg('--spsProfileInterval', dest='gecko_profile_interval', type=int,
+ help="(Deprecated - Use --geckoProfileInterval instead.) How "
+ "frequently to take samples (ms)")
+ add_arg('--spsProfileEntries', dest="gecko_profile_entries", type=int,
+ help="(Deprecated - Use --geckoProfileEntries instead.) How "
+ "many samples to take with the profiler")
+ add_arg('--geckoProfile', action="store_true", dest="gecko_profile",
+ help="Profile the run and output the results in $MOZ_UPLOAD_DIR.")
+ add_arg('--geckoProfileInterval', dest='gecko_profile_interval', type=int,
help="How frequently to take samples (ms)")
- add_arg('--spsProfileEntries', dest="sps_profile_entries", type=int,
+ add_arg('--geckoProfileEntries', dest="gecko_profile_entries", type=int,
help="How many samples to take with the profiler")
add_arg('--extension', dest='extensions', action='append',
default=['${talos}/talos-powers/talos-powers-signed.xpi',
'${talos}/pageloader/pageloader-signed.xpi'],
help="Extension to install while running")
add_arg('--fast', action='store_true',
help="Run tp tests as tp_fast")
add_arg('--symbolsPath', dest='symbols_path',
--- a/testing/talos/talos/config.py
+++ b/testing/talos/talos/config.py
@@ -23,19 +23,19 @@ DEFAULTS = dict(
init_url='getInfo.html',
env={'NO_EM_RESTART': '1'},
# base data for all tests
basetest=dict(
cycles=1,
profile_path='${talos}/base_profile',
responsiveness=False,
e10s=False,
- sps_profile=False,
- sps_profile_interval=1,
- sps_profile_entries=100000,
+ gecko_profile=False,
+ gecko_profile_interval=1,
+ gecko_profile_entries=100000,
resolution=1,
rss=False,
mainthread=False,
shutdown=False,
timeout=3600,
tpchrome=True,
tpcycles=10,
tpmozafterpaint=False,
@@ -186,19 +186,19 @@ DEFAULTS = dict(
'media.libavcodec.allow-obsolete': True
}
)
# keys to generated self.config that are global overrides to tests
GLOBAL_OVERRIDES = (
'cycles',
- 'sps_profile',
- 'sps_profile_interval',
- 'sps_profile_entries',
+ 'gecko_profile',
+ 'gecko_profile_interval',
+ 'gecko_profile_entries',
'rss',
'mainthread',
'shutdown',
'tpcycles',
'tpdelay',
'tppagecycles',
'tpmanifest',
'tptimeout',
@@ -315,17 +315,17 @@ def get_active_tests(config):
def get_global_overrides(config):
global_overrides = {}
for key in GLOBAL_OVERRIDES:
# get global overrides for all tests
value = config[key]
if value is not None:
global_overrides[key] = value
- if key != 'sps_profile':
+ if key != 'gecko_profile':
config.pop(key)
# add noChrome to global overrides (HACK)
noChrome = config.pop('noChrome')
if noChrome:
global_overrides['tpchrome'] = False
# HACK: currently xperf tests post results to graph server and
--- a/testing/talos/talos/ffsetup.py
+++ b/testing/talos/talos/ffsetup.py
@@ -12,33 +12,33 @@ import tempfile
import mozfile
from mozprocess import ProcessHandler
from mozprofile.profile import Profile
from mozlog import get_proxy_logger
from talos import utils
from talos.utils import TalosError
-from talos.sps_profile import SpsProfile
+from talos.gecko_profile import GeckoProfile
LOG = get_proxy_logger()
class FFSetup(object):
"""
Initialize the browser environment before running a test.
This prepares:
- the environment vars for running the test in the browser,
available via the instance member *env*.
- the profile used to run the test, available via the
instance member *profile_dir*.
- - sps profiling, available via the instance member *sps_profile*
- of type :class:`SpsProfile` or None if not used.
+ - Gecko profiling, available via the instance member *gecko_profile*
+ of type :class:`GeckoProfile` or None if not used.
Note that the browser will be run once with the profile, to ensure
this is basically working and negate any performance noise with the
real test run (installing the profile the first time takes time).
This class should be used as a context manager::
with FFSetup(browser_config, test_config) as setup:
@@ -52,17 +52,17 @@ class FFSetup(object):
def __init__(self, browser_config, test_config):
self.browser_config, self.test_config = browser_config, test_config
self._tmp_dir = tempfile.mkdtemp()
self.env = None
# The profile dir must be named 'profile' because of xperf analysis
# (in etlparser.py). TODO fix that ?
self.profile_dir = os.path.join(self._tmp_dir, 'profile')
- self.sps_profile = None
+ self.gecko_profile = None
def _init_env(self):
self.env = dict(os.environ)
for k, v in self.browser_config['env'].iteritems():
self.env[k] = str(v)
self.env['MOZ_CRASHREPORTER_NO_REPORT'] = '1'
if self.browser_config['symbols_path']:
self.env['MOZ_CRASHREPORTER'] = '1'
@@ -132,40 +132,40 @@ class FFSetup(object):
results_raw = '\n'.join(browser.output)
if not self.PROFILE_REGEX.search(results_raw):
LOG.info("Could not find %s in browser output"
% self.PROFILE_REGEX.pattern)
LOG.info("Raw results:%s" % results_raw)
raise TalosError("browser failed to close after being initialized")
- def _init_sps_profile(self):
+ def _init_gecko_profile(self):
upload_dir = os.getenv('MOZ_UPLOAD_DIR')
- if self.test_config.get('sps_profile') and not upload_dir:
+ if self.test_config.get('gecko_profile') and not upload_dir:
LOG.critical("Profiling ignored because MOZ_UPLOAD_DIR was not"
" set")
- if upload_dir and self.test_config.get('sps_profile'):
- self.sps_profile = SpsProfile(upload_dir,
- self.browser_config,
- self.test_config)
- self.sps_profile.update_env(self.env)
+ if upload_dir and self.test_config.get('gecko_profile'):
+ self.gecko_profile = GeckoProfile(upload_dir,
+ self.browser_config,
+ self.test_config)
+ self.gecko_profile.update_env(self.env)
def clean(self):
mozfile.remove(self._tmp_dir)
- if self.sps_profile:
- self.sps_profile.clean()
+ if self.gecko_profile:
+ self.gecko_profile.clean()
def __enter__(self):
LOG.info('Initialising browser for %s test...'
% self.test_config['name'])
self._init_env()
self._init_profile()
try:
self._run_profile()
except:
self.clean()
raise
- self._init_sps_profile()
+ self._init_gecko_profile()
LOG.info('Browser initialized.')
return self
def __exit__(self, type, value, tb):
self.clean()
rename from testing/talos/talos/sps_profile.py
rename to testing/talos/talos/gecko_profile.py
--- a/testing/talos/talos/sps_profile.py
+++ b/testing/talos/talos/gecko_profile.py
@@ -1,121 +1,121 @@
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
"""
-module to handle sps profilling.
+module to handle Gecko profilling.
"""
import os
import tempfile
import zipfile
import json
import mozfile
from mozlog import get_proxy_logger
-from talos.profiler import symbolication, sps
+from talos.profiler import symbolication, profiling
LOG = get_proxy_logger()
-class SpsProfile(object):
+class GeckoProfile(object):
"""
- Handle sps profilling.
+ Handle Gecko profilling.
- This allow to collect sps profiling data and to zip results in one file.
+ This allow to collect Gecko profiling data and to zip results in one file.
"""
def __init__(self, upload_dir, browser_config, test_config):
self.upload_dir = upload_dir
self.browser_config, self.test_config = browser_config, test_config
# Create a temporary directory into which the tests can put
# their profiles. These files will be assembled into one big
# zip file later on, which is put into the MOZ_UPLOAD_DIR.
- sps_profile_dir = tempfile.mkdtemp()
+ gecko_profile_dir = tempfile.mkdtemp()
- sps_profile_interval = test_config.get('sps_profile_interval', 1)
- sps_profile_entries = test_config.get('sps_profile_entries', 1000000)
- sps_profile_threads = 'GeckoMain,Compositor'
+ gecko_profile_interval = test_config.get('gecko_profile_interval', 1)
+ gecko_profile_entries = test_config.get('gecko_profile_entries', 1000000)
+ gecko_profile_threads = 'GeckoMain,Compositor'
# Make sure no archive already exists in the location where
# we plan to output our profiler archive
self.profile_arcname = os.path.join(
self.upload_dir,
- "profile_{0}.sps.zip".format(test_config['name'])
+ "profile_{0}.zip".format(test_config['name'])
)
LOG.info("Clearing archive {0}".format(self.profile_arcname))
mozfile.remove(self.profile_arcname)
self.symbol_paths = {
'FIREFOX': tempfile.mkdtemp(),
'THUNDERBIRD': tempfile.mkdtemp(),
'WINDOWS': tempfile.mkdtemp()
}
LOG.info("Activating Gecko Profiling. Temp. profile dir:"
" {0}, interval: {1}, entries: {2}"
- .format(sps_profile_dir,
- sps_profile_interval,
- sps_profile_entries))
+ .format(gecko_profile_dir,
+ gecko_profile_interval,
+ gecko_profile_entries))
self.profiling_info = {
- "sps_profile_interval": sps_profile_interval,
- "sps_profile_entries": sps_profile_entries,
- "sps_profile_dir": sps_profile_dir,
- "sps_profile_threads": sps_profile_threads
+ "gecko_profile_interval": gecko_profile_interval,
+ "gecko_profile_entries": gecko_profile_entries,
+ "gecko_profile_dir": gecko_profile_dir,
+ "gecko_profile_threads": gecko_profile_threads
}
def option(self, name):
- return self.profiling_info["sps_profile_" + name]
+ return self.profiling_info["gecko_profile_" + name]
def update_env(self, env):
"""
update the given env to update some env vars if required.
"""
- if not self.test_config.get('sps_profile_startup'):
+ if not self.test_config.get('gecko_profile_startup'):
return
# Set environment variables which will cause profiling to
# start as early as possible. These are consumed by Gecko
# itself, not by Talos JS code.
env.update({
'MOZ_PROFILER_STARTUP': '1',
'MOZ_PROFILER_INTERVAL': str(self.option('interval')),
'MOZ_PROFILER_ENTRIES': str(self.option('entries')),
"MOZ_PROFILER_THREADS": str(self.option('threads'))
})
- def _save_sps_profile(self, cycle, symbolicator, missing_symbols_zip,
+ def _save_gecko_profile(self, cycle, symbolicator, missing_symbols_zip,
profile_path):
try:
with open(profile_path, 'r') as profile_file:
profile = json.load(profile_file)
symbolicator.dump_and_integrate_missing_symbols(
profile,
missing_symbols_zip)
symbolicator.symbolicate_profile(profile)
- sps.save_profile(profile, profile_path)
+ profiling.save_profile(profile, profile_path)
except MemoryError:
LOG.critical(
"Ran out of memory while trying"
" to symbolicate profile {0} (cycle {1})"
.format(profile_path, cycle),
exc_info=True
)
except Exception:
LOG.critical("Encountered an exception during profile"
" symbolication {0} (cycle {1})"
.format(profile_path, cycle),
exc_info=True)
def symbolicate(self, cycle):
"""
- Symbolicate sps profiling data for one cycle.
+ Symbolicate Gecko profiling data for one cycle.
:param cycle: the number of the cycle of the test currently run.
"""
symbolicator = symbolication.ProfileSymbolicator({
# Trace-level logging (verbose)
"enableTracing": 0,
# Fallback server if symbol is not found locally
"remoteSymbolServer":
@@ -153,38 +153,38 @@ class SpsProfile(object):
missing_symbols_zip = os.path.join(self.upload_dir,
"missingsymbols.zip")
try:
mode = zipfile.ZIP_DEFLATED
except NameError:
mode = zipfile.ZIP_STORED
- sps_profile_dir = self.option('dir')
+ gecko_profile_dir = self.option('dir')
with zipfile.ZipFile(self.profile_arcname, 'a', mode) as arc:
# Collect all individual profiles that the test
- # has put into sps_profile_dir.
- for profile_filename in os.listdir(sps_profile_dir):
+ # has put into gecko_profile_dir.
+ for profile_filename in os.listdir(gecko_profile_dir):
testname = profile_filename
- if testname.endswith(".sps"):
- testname = testname[0:-4]
- profile_path = os.path.join(sps_profile_dir, profile_filename)
- self._save_sps_profile(cycle, symbolicator,
+ if testname.endswith(".profile"):
+ testname = testname[0:-8]
+ profile_path = os.path.join(gecko_profile_dir, profile_filename)
+ self._save_gecko_profile(cycle, symbolicator,
missing_symbols_zip,
profile_path)
# Our zip will contain one directory per subtest,
# and each subtest directory will contain one or
- # more cycle_i.sps files. For example, with
+ # more cycle_i.profile files. For example, with
# test_config['name'] == 'tscrollx',
- # profile_filename == 'iframe.svg.sps', i == 0,
+ # profile_filename == 'iframe.svg.profile', i == 0,
# we'll get path_in_zip ==
- # 'profile_tscrollx/iframe.svg/cycle_0.sps'.
- cycle_name = "cycle_{0}.sps".format(cycle)
+ # 'profile_tscrollx/iframe.svg/cycle_0.profile'.
+ cycle_name = "cycle_{0}.profile".format(cycle)
path_in_zip = \
os.path.join(
"profile_{0}".format(self.test_config['name']),
testname,
cycle_name
)
LOG.info(
"Adding profile {0} to archive {1}"
--- a/testing/talos/talos/output.py
+++ b/testing/talos/talos/output.py
@@ -188,17 +188,17 @@ class Output(object):
else:
raise NotImplementedError(
"%s: %s - only http://, https://, and file:// supported"
% (self.__class__.__name__, results_url)
)
# This is the output that treeherder expects to find when parsing the
# log file
- if 'spsProfile' not in self.results.extra_options:
+ if 'geckoProfile' not in self.results.extra_options:
LOG.info("PERFHERDER_DATA: %s" % json.dumps(results))
if results_scheme in ('file'):
json.dump(results, open(results_path, 'w'), indent=2,
sort_keys=True)
def post(self, results, server, path, scheme, tbpl_output):
raise NotImplementedError("Abstract base class")
--- a/testing/talos/talos/pageloader/chrome/Profiler.js
+++ b/testing/talos/talos/pageloader/chrome/Profiler.js
@@ -95,27 +95,27 @@ var Profiler;
profiler_threadsArray, profiler_threadsArray.length);
if (_profiler.PauseSampling) {
_profiler.PauseSampling();
}
}
},
finishTest: function Profiler__finishTest () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".profile");
_profiler.StopProfiler();
}
},
finishTestAsync: function Profiler__finishTest () {
if (!(_profiler && enabled)) {
return;
}
return new Promise((resolve, reject) => {
Services.profiler.getProfileDataAsync().then((profile) => {
- let profileFile = profiler_dir + "/" + currentTest + ".sps";
+ let profileFile = profiler_dir + "/" + currentTest + ".profile";
Components.utils.import("resource://gre/modules/NetUtil.jsm");
Components.utils.import("resource://gre/modules/FileUtils.jsm");
var file = Components.classes["@mozilla.org/file/local;1"].
createInstance(Components.interfaces.nsILocalFile);
file.initWithPath(profileFile);
@@ -138,17 +138,17 @@ var Profiler;
}, (error) => {
Cu.reportError("Failed to gather profile: " + error);
reject();
});
});
},
finishStartupProfiling: function Profiler__finishStartupProfiling () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/startup.sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/startup.profile");
_profiler.StopProfiler();
}
},
resume: function Profiler__resume (name, explicit) {
if (_profiler) {
if (_profiler.ResumeSampling) {
_profiler.ResumeSampling();
}
rename from testing/talos/talos/profiler/sps.py
rename to testing/talos/talos/profiler/profiling.py
--- a/testing/talos/talos/run_tests.py
+++ b/testing/talos/talos/run_tests.py
@@ -43,18 +43,18 @@ def buildCommandLine(test):
if test['tpcycles'] not in range(1, 1000):
raise TalosError('pageloader cycles must be int 1 to 1,000')
if test.get('tpdelay') and test['tpdelay'] not in range(1, 10000):
raise TalosError('pageloader delay must be int 1 to 10,000')
if 'tpmanifest' not in test:
raise TalosError("tpmanifest not found in test: %s" % test)
# if profiling is on, override tppagecycles to prevent test hanging
- if test['sps_profile']:
- LOG.info("sps profiling is enabled so talos is reducing the number "
+ if test['gecko_profile']:
+ LOG.info("Gecko profiling is enabled so talos is reducing the number "
"of cycles, please disregard reported numbers")
for cycle_var in ['tppagecycles', 'tpcycles', 'cycles']:
if test[cycle_var] > 2:
test[cycle_var] = 2
# build pageloader command from options
url = ['-tp', test['tpmanifest']]
CLI_bool_options = ['tpchrome', 'tpmozafterpaint', 'tpdisable_e10s',
@@ -164,35 +164,35 @@ def run_tests(config, browser_config):
date = int(time.time())
LOG.debug("using testdate: %d" % date)
LOG.debug("actual date: %d" % int(time.time()))
# results container
talos_results = TalosResults()
# results links
- if not browser_config['develop'] and not config['sps_profile']:
+ if not browser_config['develop'] and not config['gecko_profile']:
results_urls = dict(
# another hack; datazilla stands for Perfherder
# and do not require url, but a non empty dict is required...
output_urls=['local.json'],
)
else:
# local mode, output to files
results_urls = dict(output_urls=[os.path.abspath('local.json')])
httpd = setup_webserver(browser_config['webserver'])
httpd.start()
# if e10s add as extra results option
if config['e10s']:
talos_results.add_extra_option('e10s')
- if config['sps_profile']:
- talos_results.add_extra_option('spsProfile')
+ if config['gecko_profile']:
+ talos_results.add_extra_option('geckoProfile')
testname = None
# run the tests
timer = utils.Timer()
LOG.suite_start(tests=[test['name'] for test in tests])
try:
for test in tests:
testname = test['name']
@@ -222,17 +222,17 @@ def run_tests(config, browser_config):
LOG.suite_end()
httpd.stop()
LOG.info("Completed test suite (%s)" % timer.elapsed())
# output results
if results_urls:
talos_results.output(results_urls)
- if browser_config['develop'] or config['sps_profile']:
+ if browser_config['develop'] or config['gecko_profile']:
print("Thanks for running Talos locally. Results are in %s"
% (results_urls['output_urls']))
# we will stop running tests on a failed test, or we will return 0 for
# green
return 0
--- a/testing/talos/talos/scripts/Profiler.js
+++ b/testing/talos/talos/scripts/Profiler.js
@@ -95,23 +95,23 @@ var Profiler;
profiler_threadsArray, profiler_threadsArray.length);
if (_profiler.PauseSampling) {
_profiler.PauseSampling();
}
}
},
finishTest: function Profiler__finishTest () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".profile");
_profiler.StopProfiler();
}
},
finishStartupProfiling: function Profiler__finishStartupProfiling () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/startup.sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/startup.profile");
_profiler.StopProfiler();
}
},
resume: function Profiler__resume (name, explicit) {
if (_profiler) {
if (_profiler.ResumeSampling) {
_profiler.ResumeSampling();
}
--- a/testing/talos/talos/startup_test/tresize/addon/content/Profiler.js
+++ b/testing/talos/talos/startup_test/tresize/addon/content/Profiler.js
@@ -95,23 +95,23 @@ var Profiler;
profiler_threadsArray, profiler_threadsArray.length);
if (_profiler.PauseSampling) {
_profiler.PauseSampling();
}
}
},
finishTest: function Profiler__finishTest () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".profile");
_profiler.StopProfiler();
}
},
finishStartupProfiling: function Profiler__finishStartupProfiling () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/startup.sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/startup.profile");
_profiler.StopProfiler();
}
},
resume: function Profiler__resume (name, explicit) {
if (_profiler) {
if (_profiler.ResumeSampling) {
_profiler.ResumeSampling();
}
--- a/testing/talos/talos/talos-powers/content/TalosContentProfiler.js
+++ b/testing/talos/talos/talos-powers/content/TalosContentProfiler.js
@@ -167,17 +167,17 @@ var TalosContentProfiler;
* finished dumping the multi-process profile to disk.
*
* @returns Promise
* Resolves once the profile has been dumped to disk. The test should
* not try to quit the browser until this has resolved.
*/
finishTest() {
if (initted) {
- let profileFile = profileDir + "/" + currentTest + ".sps";
+ let profileFile = profileDir + "/" + currentTest + ".profile";
return sendEventAndWait("Profiler:Finish", { profileFile });
} else {
var msg = "You should not call finishTest without having first " +
"initted the Profiler";
console.error(msg);
return Promise.reject(msg);
}
},
@@ -188,17 +188,17 @@ var TalosContentProfiler;
* this function to dump the profile.
*
* @returns Promise
* Resolves once the profile has been dumped to disk. The test should
* not try to quit the browser until this has resolved.
*/
finishStartupProfiling() {
if (initted) {
- let profileFile = profileDir + "/startup.sps";
+ let profileFile = profileDir + "/startup.profile";
return sendEventAndWait("Profiler:Finish", { profileFile });
}
return Promise.resolve();
},
/**
* Resumes the Gecko Profiler sampler. Can also simultaneously set a marker.
*
--- a/testing/talos/talos/talos-powers/content/TalosParentProfiler.js
+++ b/testing/talos/talos/talos-powers/content/TalosParentProfiler.js
@@ -126,17 +126,17 @@ var TalosParentProfiler;
* finished dumping the multi-process profile to disk.
*
* @returns Promise
* Resolves once the profile has been dumped to disk. The test should
* not try to quit the browser until this has resolved.
*/
finishTest() {
if (initted) {
- let profileFile = profileDir + "/" + currentTest + ".sps";
+ let profileFile = profileDir + "/" + currentTest + ".profile";
return TalosPowers.profilerFinish(profileFile);
} else {
let msg = "You should not call finishTest without having first " +
"initted the Profiler";
console.error(msg);
return Promise.reject(msg);
}
},
@@ -147,17 +147,17 @@ var TalosParentProfiler;
* this function to dump the profile.
*
* @returns Promise
* Resolves once the profile has been dumped to disk. The test should
* not try to quit the browser until this has resolved.
*/
finishStartupProfiling() {
if (initted) {
- let profileFile = profileDir + "/startup.sps";
+ let profileFile = profileDir + "/startup.profile";
return TalosPowers.profilerFinish(profileFile);
}
return Promise.resolve();
},
/**
* Resumes the Gecko Profiler sampler. Can also simultaneously set a marker.
*
--- a/testing/talos/talos/test.py
+++ b/testing/talos/talos/test.py
@@ -89,20 +89,20 @@ class TsBase(Test):
# Otherwise, ignore shutdown data
# (__startTimestamp/__endTimestamp is still
# required but ignored).
'profile_path', # The path containing the template profile. This
# directory is copied to the temporary profile during
# initialization of the test. If some of the files may
# be overwritten by Firefox and need to be reinstalled
# before each pass, use key |reinstall|
- 'sps_profile',
- 'sps_profile_interval',
- 'sps_profile_entries',
- 'sps_profile_startup',
+ 'gecko_profile',
+ 'gecko_profile_interval',
+ 'gecko_profile_entries',
+ 'gecko_profile_startup',
'preferences',
'xperf_counters',
'xperf_providers',
'xperf_user_providers',
'xperf_stackwalk',
'tpmozafterpaint',
'extensions',
'filters',
@@ -122,18 +122,18 @@ class TsBase(Test):
class ts_paint(TsBase):
"""
Launches tspaint_test.html with the current timestamp in the url,
waits for [MozAfterPaint and onLoad] to fire, then records the end
time and calculates the time to startup.
"""
cycles = 20
timeout = 150
- sps_profile_startup = True
- sps_profile_entries = 10000000
+ gecko_profile_startup = True
+ gecko_profile_entries = 10000000
url = 'startup_test/tspaint_test.html'
shutdown = False
xperf_counters = []
win7_counters = []
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
tpmozafterpaint = True
rss = False
mainthread = False
@@ -149,18 +149,18 @@ class sessionrestore(TsBase):
1. Set up Firefox to restore from a given sessionstore.js file.
2. Launch Firefox.
3. Measure the delta between firstPaint and sessionRestored.
"""
extensions = \
'${talos}/startup_test/sessionrestore/addon/sessionrestore-signed.xpi'
cycles = 10
timeout = 1000000
- sps_profile_startup = True
- sps_profile_entries = 10000000
+ gecko_profile_startup = True
+ gecko_profile_entries = 10000000
profile_path = '${talos}/startup_test/sessionrestore/profile'
url = 'startup_test/sessionrestore/index.html'
shutdown = False
reinstall = ['sessionstore.js', 'sessionCheckpoints.json']
# Restore the session
preferences = {'browser.startup.page': 3}
unit = 'ms'
@@ -184,34 +184,34 @@ class tpaint(TsBase):
Tests the amount of time it takes the open a new window. This test does
not include startup time. Multiple test windows are opened in succession,
results reported are the average amount of time required to create and
display a window in the running instance of the browser.
(Measures ctrl-n performance.)
"""
url = 'file://${talos}/startup_test/tpaint.html?auto=1'
timeout = 300
- sps_profile_interval = 1
- sps_profile_entries = 2000000
+ gecko_profile_interval = 1
+ gecko_profile_entries = 2000000
tpmozafterpaint = True
filters = filter.ignore_first.prepare(5) + filter.median.prepare()
unit = 'ms'
@register_test()
class tresize(TsBase):
"""
This test does some resize thing.
"""
extensions = '${talos}/startup_test/tresize/addon/tresize-signed.xpi'
cycles = 20
url = 'startup_test/tresize/addon/content/tresize-test.html'
timeout = 150
- sps_profile_interval = 2
- sps_profile_entries = 1000000
+ gecko_profile_interval = 2
+ gecko_profile_entries = 1000000
tpmozafterpaint = True
filters = filter.ignore_first.prepare(5) + filter.median.prepare()
unit = 'ms'
# pageloader tests(tp5, etc)
# The overall test number is determined by first calculating the median
@@ -224,35 +224,35 @@ class tresize(TsBase):
class PageloaderTest(Test):
"""abstract base class for a Talos Pageloader test"""
tpmanifest = None # test manifest
tpcycles = 1 # number of time to run each page
cycles = None
timeout = None
keys = ['tpmanifest', 'tpcycles', 'tppagecycles', 'tprender', 'tpchrome',
'tpmozafterpaint', 'tploadnocache', 'rss', 'mainthread',
- 'resolution', 'cycles', 'sps_profile', 'sps_profile_interval',
- 'sps_profile_entries', 'tptimeout', 'win_counters', 'w7_counters',
+ 'resolution', 'cycles', 'gecko_profile', 'gecko_profile_interval',
+ 'gecko_profile_entries', 'tptimeout', 'win_counters', 'w7_counters',
'linux_counters', 'mac_counters', 'tpscrolltest', 'xperf_counters',
'timeout', 'shutdown', 'responsiveness', 'profile_path',
'xperf_providers', 'xperf_user_providers', 'xperf_stackwalk',
'filters', 'preferences', 'extensions', 'setup', 'cleanup',
'lower_is_better', 'alert_threshold', 'unit']
@register_test()
class tabpaint(PageloaderTest):
"""
Tests the amount of time it takes to open new tabs, triggered from
both the parent process and the content process.
"""
extensions = '${talos}/tests/tabpaint/tabpaint-signed.xpi'
tpmanifest = '${talos}/tests/tabpaint/tabpaint.manifest'
tppagecycles = 20
- sps_profile_entries = 1000000
+ gecko_profile_entries = 1000000
tploadnocache = True
unit = 'ms'
preferences = {
# By default, Talos is configured to open links from
# content in new windows. We're overriding them so that
# they open in new tabs instead.
# See http://kb.mozillazine.org/Browser.link.open_newwindow
# and http://kb.mozillazine.org/Browser.link.open_newwindow.restriction
@@ -264,17 +264,17 @@ class tabpaint(PageloaderTest):
@register_test()
class tps(PageloaderTest):
"""
Tests the amount of time it takes to switch between tabs
"""
extensions = '${talos}/tests/tabswitch/tabswitch-signed.xpi'
tpmanifest = '${talos}/tests/tabswitch/tps.manifest'
tppagecycles = 5
- sps_profile_entries = 1000000
+ gecko_profile_entries = 1000000
tploadnocache = True
preferences = {
'addon.test.tabswitch.urlfile': os.path.join('${talos}',
'tests',
'tp5o.html'),
'addon.test.tabswitch.webserver': '${webserver}',
# limit the page set number for winxp as we have issues.
# see https://bugzilla.mozilla.org/show_bug.cgi?id=1195288
@@ -308,18 +308,18 @@ class tart(PageloaderTest):
- all: average interval over all recorded intervals.
"""
tpmanifest = '${talos}/tests/tart/tart.manifest'
extensions = '${talos}/tests/tart/addon/tart-signed.xpi'
tpcycles = 1
tppagecycles = 25
tploadnocache = True
tpmozafterpaint = False
- sps_profile_interval = 10
- sps_profile_entries = 1000000
+ gecko_profile_interval = 10
+ gecko_profile_entries = 1000000
win_counters = w7_counters = linux_counters = mac_counters = None
"""
ASAP mode
The recording API is broken with OMTC before ~2013-11-27
After ~2013-11-27, disabling OMTC will also implicitly disable
OGL HW composition to disable OMTC with older firefox builds, also
set 'layers.offmainthreadcomposition.enabled': False
"""
@@ -345,18 +345,18 @@ class cart(PageloaderTest):
3-customize-enter-css - only the CSS animation part of entering customize
"""
tpmanifest = '${talos}/tests/tart/cart.manifest'
extensions = '${talos}/tests/tart/addon/tart-signed.xpi'
tpcycles = 1
tppagecycles = 25
tploadnocache = True
tpmozafterpaint = False
- sps_profile_interval = 1
- sps_profile_entries = 10000000
+ gecko_profile_interval = 1
+ gecko_profile_entries = 10000000
win_counters = w7_counters = linux_counters = mac_counters = None
"""
ASAP mode
"""
preferences = {'layout.frame_rate': 0,
'docshell.event_starvation_delay_hint': 1,
'dom.send_after_paint_to_content': False}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
@@ -371,18 +371,18 @@ class damp(PageloaderTest):
for each tool, across a very simple and very complicated page.
"""
tpmanifest = '${talos}/tests/devtools/damp.manifest'
extensions = '${talos}/tests/devtools/addon/devtools-signed.xpi'
tpcycles = 1
tppagecycles = 25
tploadnocache = True
tpmozafterpaint = False
- sps_profile_interval = 10
- sps_profile_entries = 1000000
+ gecko_profile_interval = 10
+ gecko_profile_entries = 1000000
win_counters = w7_counters = linux_counters = mac_counters = None
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
preferences = {'devtools.memory.enabled': True,
'addon.test.damp.webserver': '${webserver}'}
unit = 'ms'
@register_test()
@@ -395,18 +395,18 @@ class glterrain(PageloaderTest):
antialias as canvas properties.
Each of these 4 runs is reported as a different test name.
"""
tpmanifest = '${talos}/tests/webgl/glterrain.manifest'
tpcycles = 1
tppagecycles = 25
tploadnocache = True
tpmozafterpaint = False
- sps_profile_interval = 10
- sps_profile_entries = 2000000
+ gecko_profile_interval = 10
+ gecko_profile_entries = 2000000
win_counters = w7_counters = linux_counters = mac_counters = None
""" ASAP mode """
preferences = {'layout.frame_rate': 0,
'docshell.event_starvation_delay_hint': 1,
'dom.send_after_paint_to_content': False}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = 'frame interval'
@@ -470,33 +470,33 @@ class tp5o(PageloaderTest):
mainthread = False
tpmanifest = '${talos}/tests/tp5n/tp5o.manifest'
win_counters = ['Main_RSS', 'Private Bytes', '% Processor Time']
w7_counters = ['Main_RSS', 'Private Bytes', '% Processor Time',
'Modified Page List Bytes']
linux_counters = ['Private Bytes', 'XRes', 'Main_RSS']
mac_counters = ['Main_RSS']
responsiveness = True
- sps_profile_interval = 2
- sps_profile_entries = 4000000
+ gecko_profile_interval = 2
+ gecko_profile_entries = 4000000
filters = filter.ignore_first.prepare(5) + filter.median.prepare()
timeout = 1800
unit = 'ms'
@register_test()
class tp5o_scroll(PageloaderTest):
"""
Tests scroll (like tscrollx does, including ASAP) but on the tp5o pageset.
"""
tpmanifest = '${talos}/tests/tp5n/tp5o.manifest'
tpcycles = 1
tppagecycles = 12
- sps_profile_interval = 2
- sps_profile_entries = 2000000
+ gecko_profile_interval = 2
+ gecko_profile_entries = 2000000
tpscrolltest = True
"""ASAP mode"""
tpmozafterpaint = False
preferences = {'layout.frame_rate': 0,
'docshell.event_starvation_delay_hint': 1,
'dom.send_after_paint_to_content': False,
'layout.css.scroll-behavior.spring-constant': "'10'",
@@ -510,18 +510,18 @@ class v8_7(PageloaderTest):
"""
This is the V8 (version 7) javascript benchmark taken verbatim and
slightly modified to fit into our pageloader extension and talos harness.
The previous version of this test is V8 version 5 which was run on
selective branches and operating systems.
"""
tpmanifest = '${talos}/tests/v8_7/v8.manifest'
- sps_profile_interval = 1
- sps_profile_entries = 1000000
+ gecko_profile_interval = 1
+ gecko_profile_entries = 1000000
tpcycles = 1
resolution = 20
tpmozafterpaint = False
preferences = {'dom.send_after_paint_to_content': False}
filters = filter.v8_subtest.prepare()
unit = 'score'
lower_is_better = False
@@ -530,35 +530,35 @@ class v8_7(PageloaderTest):
class kraken(PageloaderTest):
"""
This is the Kraken javascript benchmark taken verbatim and slightly
modified to fit into our pageloader extension and talos harness.
"""
tpmanifest = '${talos}/tests/kraken/kraken.manifest'
tpcycles = 1
tppagecycles = 1
- sps_profile_interval = 0.1
- sps_profile_entries = 1000000
+ gecko_profile_interval = 0.1
+ gecko_profile_entries = 1000000
tpmozafterpaint = False
preferences = {'dom.send_after_paint_to_content': False}
filters = filter.mean.prepare()
unit = 'score'
@register_test()
class basic_compositor_video(PageloaderTest):
"""
Video test
"""
tpmanifest = '${talos}/tests/video/video.manifest'
tpcycles = 1
tppagecycles = 12
timeout = 10000
- sps_profile_interval = 1
- sps_profile_entries = 2000000
+ gecko_profile_interval = 1
+ gecko_profile_entries = 2000000
preferences = {'full-screen-api.allow-trusted-requests-only': False,
'layers.acceleration.force-enabled': False,
'layers.acceleration.disabled': True,
'layout.frame_rate': 0,
'docshell.event_starvation_delay_hint': 1,
'full-screen-api.warning.timeout': 500,
'media.ruin-av-sync.enabled': True}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
@@ -571,18 +571,18 @@ class tcanvasmark(PageloaderTest):
"""
CanvasMark benchmark v0.6
"""
tpmanifest = '${talos}/tests/canvasmark/canvasmark.manifest'
win_counters = w7_counters = linux_counters = mac_counters = None
tpcycles = 5
tppagecycles = 1
timeout = 900
- sps_profile_interval = 10
- sps_profile_entries = 2500000
+ gecko_profile_interval = 10
+ gecko_profile_entries = 2500000
tpmozafterpaint = False
preferences = {'dom.send_after_paint_to_content': False}
filters = filter.ignore_first.prepare(1) + filter.median.prepare()
unit = 'score'
lower_is_better = False
class dromaeo(PageloaderTest):
@@ -596,50 +596,50 @@ class dromaeo(PageloaderTest):
class dromaeo_css(dromaeo):
"""
Dromaeo suite of tests for JavaScript performance testing.
See the Dromaeo wiki (https://wiki.mozilla.org/Dromaeo)
for more information.
Each page in the manifest is part of the dromaemo css benchmark.
"""
- sps_profile_interval = 2
- sps_profile_entries = 10000000
+ gecko_profile_interval = 2
+ gecko_profile_entries = 10000000
tpmanifest = '${talos}/tests/dromaeo/css.manifest'
unit = 'score'
@register_test()
class dromaeo_dom(dromaeo):
"""
Dromaeo suite of tests for JavaScript performance testing.
See the Dromaeo wiki (https://wiki.mozilla.org/Dromaeo)
for more information.
Each page in the manifest is part of the dromaemo dom benchmark.
"""
- sps_profile_interval = 2
- sps_profile_entries = 10000000
+ gecko_profile_interval = 2
+ gecko_profile_entries = 10000000
tpmanifest = '${talos}/tests/dromaeo/dom.manifest'
tpdisable_e10s = True
unit = 'score'
@register_test()
class tsvgm(PageloaderTest):
"""
An svg-only number that measures SVG rendering performance
for dynamic content only.
"""
tpmanifest = '${talos}/tests/svgx/svgm.manifest'
tpcycles = 1
tppagecycles = 7
tpmozafterpaint = False
- sps_profile_interval = 10
- sps_profile_entries = 1000000
+ gecko_profile_interval = 10
+ gecko_profile_entries = 1000000
"""ASAP mode"""
preferences = {'layout.frame_rate': 0,
'docshell.event_starvation_delay_hint': 1,
'dom.send_after_paint_to_content': False}
filters = filter.ignore_first.prepare(2) + filter.median.prepare()
unit = 'ms'
@@ -648,18 +648,18 @@ class tsvgx(PageloaderTest):
"""
An svg-only number that measures SVG rendering performance
for dynamic content only.
"""
tpmanifest = '${talos}/tests/svgx/svgx.manifest'
tpcycles = 1
tppagecycles = 25
tpmozafterpaint = False
- sps_profile_interval = 10
- sps_profile_entries = 1000000
+ gecko_profile_interval = 10
+ gecko_profile_entries = 1000000
"""ASAP mode"""
preferences = {'layout.frame_rate': 0,
'docshell.event_starvation_delay_hint': 1,
'dom.send_after_paint_to_content': False}
filters = filter.ignore_first.prepare(5) + filter.median.prepare()
unit = 'ms'
@@ -668,48 +668,48 @@ class tsvg_static(PageloaderTest):
"""
An svg-only number that measures SVG rendering performance
for static content only.
"""
tpmanifest = '${talos}/tests/svg_static/svg_static.manifest'
tpcycles = 1
tppagecycles = 25
tpmozafterpaint = True
- sps_profile_interval = 1
- sps_profile_entries = 10000000
+ gecko_profile_interval = 1
+ gecko_profile_entries = 10000000
filters = filter.ignore_first.prepare(5) + filter.median.prepare()
unit = 'ms'
@register_test()
class tsvgr_opacity(PageloaderTest):
"""
An svg-only number that measures SVG rendering performance.
"""
tpmanifest = '${talos}/tests/svg_opacity/svg_opacity.manifest'
tpcycles = 1
tppagecycles = 25
tpmozafterpaint = True
- sps_profile_interval = 1
- sps_profile_entries = 10000000
+ gecko_profile_interval = 1
+ gecko_profile_entries = 10000000
filters = filter.ignore_first.prepare(5) + filter.median.prepare()
unit = 'ms'
@register_test()
class tscrollx(PageloaderTest):
"""
This test does some scrolly thing.
"""
tpmanifest = '${talos}/tests/scroll/scroll.manifest'
tpcycles = 1
tppagecycles = 25
tpmozafterpaint = False
- sps_profile_interval = 1
- sps_profile_entries = 1000000
+ gecko_profile_interval = 1
+ gecko_profile_entries = 1000000
""" ASAP mode """
preferences = {'layout.frame_rate': 0,
'docshell.event_starvation_delay_hint': 1,
'dom.send_after_paint_to_content': False,
'layout.css.scroll-behavior.spring-constant': "'10'",
'toolkit.framesRecording.bufferSize': 10000}
filters = filter.ignore_first.prepare(5) + filter.median.prepare()
unit = 'ms'
--- a/testing/talos/talos/tests/devtools/addon/content/Profiler.js
+++ b/testing/talos/talos/tests/devtools/addon/content/Profiler.js
@@ -95,23 +95,23 @@ var Profiler;
profiler_threadsArray, profiler_threadsArray.length);
if (_profiler.PauseSampling) {
_profiler.PauseSampling();
}
}
},
finishTest: function Profiler__finishTest () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".profile");
_profiler.StopProfiler();
}
},
finishStartupProfiling: function Profiler__finishStartupProfiling () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/startup.sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/startup.profile");
_profiler.StopProfiler();
}
},
resume: function Profiler__resume (name, explicit) {
if (_profiler) {
if (_profiler.ResumeSampling) {
_profiler.ResumeSampling();
}
--- a/testing/talos/talos/tests/tart/addon/content/Profiler.js
+++ b/testing/talos/talos/tests/tart/addon/content/Profiler.js
@@ -95,23 +95,23 @@ var Profiler;
profiler_threadsArray, profiler_threadsArray.length);
if (_profiler.PauseSampling) {
_profiler.PauseSampling();
}
}
},
finishTest: function Profiler__finishTest () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/" + currentTest + ".profile");
_profiler.StopProfiler();
}
},
finishStartupProfiling: function Profiler__finishStartupProfiling () {
if (_profiler && enabled) {
- _profiler.dumpProfileToFile(profiler_dir + "/startup.sps");
+ _profiler.dumpProfileToFile(profiler_dir + "/startup.profile");
_profiler.StopProfiler();
}
},
resume: function Profiler__resume (name, explicit) {
if (_profiler) {
if (_profiler.ResumeSampling) {
_profiler.ResumeSampling();
}
--- a/testing/talos/talos/ttest.py
+++ b/testing/talos/talos/ttest.py
@@ -126,28 +126,28 @@ class TTest(object):
keep)
dest = os.path.join(setup.profile_dir, keep)
LOG.debug("Reinstalling %s on top of %s"
% (origin, dest))
shutil.copy(origin, dest)
# Run the test
timeout = test_config.get('timeout', 7200) # 2 hours default
- if setup.sps_profile:
+ if setup.gecko_profile:
# When profiling, give the browser some extra time
# to dump the profile.
timeout += 5 * 60
command_args = utils.GenerateBrowserCommandLine(
browser_config["browser_path"],
browser_config["extra_args"],
setup.profile_dir,
test_config['url'],
- profiling_info=(setup.sps_profile.profiling_info
- if setup.sps_profile else None)
+ profiling_info=(setup.gecko_profile.profiling_info
+ if setup.gecko_profile else None)
)
mainthread_error_count = 0
if test_config['setup']:
# Generate bcontroller.json for xperf
talosconfig.generateTalosConfig(command_args,
browser_config,
test_config)
@@ -227,18 +227,18 @@ class TTest(object):
# add the results from the browser output
test_results.add(
'\n'.join(pcontext.output),
counter_results=(counter_management.results()
if counter_management
else None)
)
- if setup.sps_profile:
- setup.sps_profile.symbolicate(i)
+ if setup.gecko_profile:
+ setup.gecko_profile.symbolicate(i)
self.check_for_crashes(browser_config, minidump_dir,
test_config['name'])
# include global (cross-cycle) counters
test_results.all_counter_results.extend(
[{key: value} for key, value in global_counters.items()]
)