Bug 1340267 - Rename SPS to Gecko where possible within Talos. r?jmaher,mstange draft
authorMike Conley <mconley@mozilla.com>
Thu, 16 Feb 2017 15:25:31 -0500
changeset 485579 60eacdd3da926b76246fe2251b80ff180a6b8521
parent 481595 25a94c1047e793ef096d8556fa3c26dd72bd37d7
child 485580 8cceed20b6a79495281930f883e8d0e343720d9e
push id45769
push usermconley@mozilla.com
push dateThu, 16 Feb 2017 21:34:54 +0000
reviewersjmaher, mstange
bugs1340267
milestone54.0a1
Bug 1340267 - Rename SPS to Gecko where possible within Talos. r?jmaher,mstange MozReview-Commit-ID: Gt9CLIhXu6y
testing/talos/talos/cmdline.py
testing/talos/talos/config.py
testing/talos/talos/ffsetup.py
testing/talos/talos/gecko_profile.py
testing/talos/talos/output.py
testing/talos/talos/pageloader/chrome/Profiler.js
testing/talos/talos/profiler/profiling.py
testing/talos/talos/profiler/sps.py
testing/talos/talos/run_tests.py
testing/talos/talos/scripts/Profiler.js
testing/talos/talos/sps_profile.py
testing/talos/talos/startup_test/tresize/addon/content/Profiler.js
testing/talos/talos/talos-powers/content/TalosContentProfiler.js
testing/talos/talos/talos-powers/content/TalosParentProfiler.js
testing/talos/talos/test.py
testing/talos/talos/tests/devtools/addon/content/Profiler.js
testing/talos/talos/tests/tart/addon/content/Profiler.js
testing/talos/talos/ttest.py
--- 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()]
         )