Changeset 91315 in webkit


Ignore:
Timestamp:
Jul 19, 2011 3:56:06 PM (13 years ago)
Author:
eric@webkit.org
Message:

new-run-webkit-tests should only enable MallocStackLogging for DRT
​https://bugs.webkit.org/show_bug.cgi?id=64792

Reviewed by Adam Barth.

The previous code would enable it for all servers launched
by the port, which included Apache, the python websocket server
as well as ImageDiff. Now only DumpRenderTree will have
MallocStackLogging enabled or the GuardMalloc library injected.

I also cleaned up the websocket_server code to use filesystem
while I was in it.

I also made DRT restart every 1000 tests when running with
--leaks enabled. I believe this made the --leaks run slightly
faster, but it still takes over an hour on my machine. :(

  • Scripts/webkitpy/layout_tests/controllers/worker.py:
  • Scripts/webkitpy/layout_tests/port/base.py:
  • Scripts/webkitpy/layout_tests/port/chromium_win.py:
  • Scripts/webkitpy/layout_tests/port/gtk.py:
  • Scripts/webkitpy/layout_tests/port/mac.py:
  • Scripts/webkitpy/layout_tests/port/qt.py:
  • Scripts/webkitpy/layout_tests/port/server_process.py:
  • Scripts/webkitpy/layout_tests/port/webkit.py:
  • Scripts/webkitpy/layout_tests/servers/http_server.py:
  • Scripts/webkitpy/layout_tests/servers/websocket_server.py:
Location:
trunk/Tools
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Tools/ChangeLog

    r91313 r91315  
     12011-07-19  Eric Seidel  <eric@webkit.org>
     2
     3        new-run-webkit-tests should only enable MallocStackLogging for DRT
     4        https://bugs.webkit.org/show_bug.cgi?id=64792
     5
     6        Reviewed by Adam Barth.
     7
     8        The previous code would enable it for all servers launched
     9        by the port, which included Apache, the python websocket server
     10        as well as ImageDiff.  Now only DumpRenderTree will have
     11        MallocStackLogging enabled or the GuardMalloc library injected.
     12
     13        I also cleaned up the websocket_server code to use filesystem
     14        while I was in it.
     15
     16        I also made DRT restart every 1000 tests when running with
     17        --leaks enabled.  I believe this made the --leaks run slightly
     18        faster, but it still takes over an hour on my machine. :(
     19
     20        * Scripts/webkitpy/layout_tests/controllers/worker.py:
     21        * Scripts/webkitpy/layout_tests/port/base.py:
     22        * Scripts/webkitpy/layout_tests/port/chromium_win.py:
     23        * Scripts/webkitpy/layout_tests/port/gtk.py:
     24        * Scripts/webkitpy/layout_tests/port/mac.py:
     25        * Scripts/webkitpy/layout_tests/port/qt.py:
     26        * Scripts/webkitpy/layout_tests/port/server_process.py:
     27        * Scripts/webkitpy/layout_tests/port/webkit.py:
     28        * Scripts/webkitpy/layout_tests/servers/http_server.py:
     29        * Scripts/webkitpy/layout_tests/servers/websocket_server.py:
     30
    1312011-07-19  Ojan Vafai  <ojan@chromium.org>
    232

  • trunk/Tools/Scripts/webkitpy/layout_tests/controllers/worker.py

    r91245 r91315  
    6969        self._batch_count = 0
    7070        self._batch_size = self._options.batch_size
    71         tests_run_filename = self._filesystem.join(port.results_directory(),
    72                                                    "tests_run%d.txt" % self._worker_number)
     71        tests_run_filename = self._filesystem.join(port.results_directory(), "tests_run%d.txt" % self._worker_number)
    7372        self._tests_run_file = self._filesystem.open_text_file_for_writing(tests_run_filename)
    7473

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/base.py

    r91245 r91315  
    235235
    236236        try:
    237             env = self.setup_environ_for_server()
     237            server_name = self._filesystem.basename(httpd_path)
     238            env = self.setup_environ_for_server(server_name)
    238239            return self._executive.run_command([httpd_path, "-v"], env=env, return_exit_code=True) == 0
    239240        except OSError:
    … …  
    663664        pass
    664665
    665     def setup_environ_for_server(self):
     666    def setup_environ_for_server(self, server_name=None):
    666667        """Perform port-specific work at the beginning of a server launch.
    667668

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/chromium_win.py

    r91245 r91315  
    9999        self._operating_system = 'win'
    100100
    101     def setup_environ_for_server(self):
     101    def setup_environ_for_server(self, server_name=None):
    102102        env = chromium.ChromiumPort.setup_environ_for_server(self)
    103103        # Put the cygwin directory first in the path to find cygwin1.dll.

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/gtk.py

    r91245 r91315  
    4545        run_xvfb = ["Xvfb", ":%d" % (display_id), "-screen",  "0", "800x600x24", "-nolisten", "tcp"]
    4646        self._xvfb_process = subprocess.Popen(run_xvfb)
    47         environment = self._port.setup_environ_for_server()
     47        server_name = self._port.driver_name()
     48        environment = self._port.setup_environ_for_server(server_name)
    4849        # We must do this here because the DISPLAY number depends on _worker_number
    4950        environment['DISPLAY'] = ":%d" % (display_id)
    50         self._server_process = server_process.ServerProcess(self._port, self._port.driver_name(), self.cmd_line(), environment)
     51        self._server_process = server_process.ServerProcess(self._port, server_name, self.cmd_line(), environment)
    5152
    5253    def stop(self):
    … …  
    6566        return GtkDriver(self, worker_number)
    6667
    67     def setup_environ_for_server(self):
    68         environment = webkit.WebKitPort.setup_environ_for_server(self)
     68    def setup_environ_for_server(self, server_name=None):
     69        environment = webkit.WebKitPort.setup_environ_for_server(self, server_name)
    6970        environment['GTK_MODULES'] = 'gail'
    7071        environment['LIBOVERLAY_SCROLLBAR'] = '0'

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/mac.py

    r91245 r91315  
    119119        _log.debug("Checking for leaks in %s" % process_name)
    120120        try:
    121             leaks_output = self._port._run_script("run-leaks", self._leaks_args(process_pid), include_configuration_arguments=False)
     121            # Oddly enough, run-leaks (or the underlying leaks tool) does not seem to always output utf-8,
     122            # thus we pass decode_output=False.  Without this code we've seen errors like:
     123            # "UnicodeDecodeError: 'utf8' codec can't decode byte 0x88 in position 779874: unexpected code byte"
     124            leaks_output = self._port._run_script("run-leaks", self._leaks_args(process_pid), include_configuration_arguments=False, decode_output=False)
    122125        except ScriptError, e:
    123126            _log.warn("Failed to run leaks tool: %s" % e.message_with_output())
    … …  
    131134        leaks_filename = self.leaks_file_name(process_name, process_pid)
    132135        leaks_output_path = self._filesystem.join(self._port.results_directory(), leaks_filename)
    133         self._filesystem.write_text_file(leaks_output_path, leaks_output)
     136        self._filesystem.write_binary_file(leaks_output_path, leaks_output)
    134137
    135138        # FIXME: Ideally we would not be logging from the worker process, but rather pass the leak
    … …  
    196199        self._operating_system = 'mac'
    197200        self._leak_detector = LeakDetector(self)
     201        if self.get_option("leaks"):
     202            # DumpRenderTree slows down noticably if we run more than about 1000 tests in a batch
     203            # with MallocStackLogging enabled.
     204            self.set_option_default("batch_size", 1000)
    198205
    199206    def baseline_search_path(self):
    … …  
    203210        return map(self._webkit_baseline_path, search_paths)
    204211
    205     def setup_environ_for_server(self):
    206         env = WebKitPort.setup_environ_for_server(self)
    207         if self.get_option('leaks'):
    208             env['MallocStackLogging'] = '1'
    209         if self.get_option('guard_malloc'):
    210             env['DYLD_INSERT_LIBRARIES'] = '/usr/lib/libgmalloc.dylib'
     212    def setup_environ_for_server(self, server_name=None):
     213        env = WebKitPort.setup_environ_for_server(self, server_name)
     214        if server_name == self.driver_name():
     215            if self.get_option('leaks'):
     216                env['MallocStackLogging'] = '1'
     217            if self.get_option('guard_malloc'):
     218                env['DYLD_INSERT_LIBRARIES'] = '/usr/lib/libgmalloc.dylib'
    211219        return env
    212220
    … …  
    245253        if not leaks_files:
    246254            return
    247         total_bytes, unique_leaks = self.parse_leak_files(leaks_files)
     255        total_bytes, unique_leaks = self._leak_detector.parse_leak_files(leaks_files)
    248256        _log.info("%s total leaks found for a total of %s!" % (self._total_leaks, total_bytes))
    249257        _log.info("%s unique leaks found!" % unique_leaks)

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/qt.py

    r90826 r91315  
    8383        return None
    8484
    85     def setup_environ_for_server(self):
    86         env = WebKitPort.setup_environ_for_server(self)
     85    def setup_environ_for_server(self, server_name=None):
     86        env = WebKitPort.setup_environ_for_server(self, server_name)
    8787        env['QTWEBKIT_PLUGIN_PATH'] = self._build_path('lib/plugins')
    8888        return env

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/server_process.py

    r91245 r91315  
    125125        except IOError, e:
    126126            self.stop()
     127            # stop() calls _reset(), so we have to set crashed to True after calling stop().
    127128            self.crashed = True
    128129
    … …  
    161162        """
    162163        if size <= 0:
    163             raise ValueError('ServerProcess.read() called with a '
    164                              'non-positive size: %d ' % size)
     164            raise ValueError('ServerProcess.read() called with a non-positive size: %d ' % size)
    165165        return self._read(timeout, size)
    166166
    … …  
    237237            return
    238238
    239         self._port.check_for_leaks(self.name(), self.pid())
     239        # Only bother to check for leaks if the process is still running.
     240        if self.poll() is None:
     241            self._port.check_for_leaks(self.name(), self.pid())
    240242
    241243        pid = self._proc.pid

  • trunk/Tools/Scripts/webkitpy/layout_tests/port/webkit.py

    r91245 r91315  
    112112        return config_args
    113113
    114     def _run_script(self, script_name, args=None, include_configuration_arguments=True):
     114    def _run_script(self, script_name, args=None, include_configuration_arguments=True, decode_output=True):
    115115        run_script_command = [self._config.script_path(script_name)]
    116116        if include_configuration_arguments:
    … …  
    118118        if args:
    119119            run_script_command.extend(args)
    120         return self._executive.run_command(run_script_command, cwd=self._config.webkit_base_dir())
     120        return self._executive.run_command(run_script_command, cwd=self._config.webkit_base_dir(), decode_output=decode_output)
    121121
    122122    def _build_driver(self):
    … …  
    445445
    446446    def start(self):
    447         environment = self._port.setup_environ_for_server()
     447        server_name = self._port.driver_name()
     448        environment = self._port.setup_environ_for_server(server_name)
    448449        environment['DYLD_FRAMEWORK_PATH'] = self._port._build_path()
    449450        # FIXME: We're assuming that WebKitTestRunner checks this DumpRenderTree-named environment variable.
    450451        environment['DUMPRENDERTREE_TEMP'] = str(self._driver_tempdir)
    451         self._server_process = server_process.ServerProcess(self._port, self._port.driver_name(), self.cmd_line(), environment)
     452        self._server_process = server_process.ServerProcess(self._port, server_name, self.cmd_line(), environment)
    452453
    453454    def poll(self):

  • trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server.py

    r90534 r91315  
    181181
    182182        self._start_cmd = start_cmd
    183         self._env = self._port_obj.setup_environ_for_server()
     183        self._env = self._port_obj.setup_environ_for_server('lighttpd')
    184184        self._mappings = mappings
    185185

  • trunk/Tools/Scripts/webkitpy/layout_tests/servers/websocket_server.py

    r90534 r91315  
    8383
    8484        # Webkit tests
     85        # FIXME: This is the wrong way to detect if we're in Chrome vs. WebKit!
     86        # The port objects are supposed to abstract this.
    8587        if self._root:
    86             self._layout_tests = os.path.abspath(self._root)
    87             self._web_socket_tests = os.path.abspath(
    88                 os.path.join(self._root, 'http', 'tests',
    89                              'websocket', 'tests'))
     88            self._layout_tests = self._filesystem.abspath(self._root)
     89            self._web_socket_tests = self._filesystem.abspath(self._filesystem.join(self._root, 'http', 'tests', 'websocket', 'tests'))
    9090        else:
    9191            try:
    9292                self._layout_tests = self._port_obj.layout_tests_dir()
    93                 self._web_socket_tests = os.path.join(self._layout_tests,
    94                      'http', 'tests', 'websocket', 'tests')
     93                self._web_socket_tests = self._filesystem.join(self._layout_tests, 'http', 'tests', 'websocket', 'tests')
    9594            except:
    9695                self._web_socket_tests = None
    … …  
    104103        time_str = time.strftime('%d%b%Y-%H%M%S')
    105104        log_file_name = self._log_prefix + time_str
     105        # FIXME: Doesn't Executive have a devnull, so that we don't have to use os.devnull directly?
    106106        self._wsin = open(os.devnull, 'r')
    107107
    108         error_log = os.path.join(self._output_dir, log_file_name + "-err.txt")
    109 
    110         output_log = os.path.join(self._output_dir, log_file_name + "-out.txt")
     108        error_log = self._filesystem.join(self._output_dir, log_file_name + "-err.txt")
     109        output_log = self._filesystem.join(self._output_dir, log_file_name + "-out.txt")
    111110        self._wsout = self._filesystem.open_text_file_for_writing(output_log)
    112111
    113112        from webkitpy.thirdparty.autoinstalled.pywebsocket import mod_pywebsocket
    114113        python_interp = sys.executable
    115         pywebsocket_base = os.path.join(
    116             os.path.dirname(os.path.dirname(os.path.dirname(
    117             os.path.abspath(__file__)))), 'thirdparty',
    118             'autoinstalled', 'pywebsocket')
    119         pywebsocket_script = os.path.join(pywebsocket_base, 'mod_pywebsocket',
    120             'standalone.py')
     114        # FIXME: Use self._filesystem.path_to_module(self.__module__) instead of __file__
     115        # I think this is trying to get the chrome directory?  Doesn't the port object know that?
     116        pywebsocket_base = self._filesystem.join(self._filesystem.dirname(self._filesystem.dirname(self._filesystem.dirname(self._filesystem.abspath(__file__)))), 'thirdparty', 'autoinstalled', 'pywebsocket')
     117        pywebsocket_script = self._filesystem.join(pywebsocket_base, 'mod_pywebsocket', 'standalone.py')
    121118        start_cmd = [
    122119            python_interp, '-u', pywebsocket_script,
    123120            '--server-host', '127.0.0.1',
    124121            '--port', str(self._port),
    125             '--document-root', os.path.join(self._layout_tests, 'http', 'tests'),
     122            # FIXME: Don't we have a self._port_obj.layout_test_path?
     123            '--document-root', self._filesystem.join(self._layout_tests, 'http', 'tests'),
    126124            '--scan-dir', self._web_socket_tests,
    127125            '--cgi-paths', '/websocket/tests',
    … …  
    129127        ]
    130128
    131         handler_map_file = os.path.join(self._web_socket_tests,
    132                                         'handler_map.txt')
    133         if os.path.exists(handler_map_file):
     129        handler_map_file = self._filesystem.join(self._web_socket_tests, 'handler_map.txt')
     130        if self._filesystem.exists(handler_map_file):
    134131            _log.debug('Using handler_map_file: %s' % handler_map_file)
    135132            start_cmd.append('--websock-handlers-map-file')
    … …  
    143140
    144141        self._start_cmd = start_cmd
    145         self._env = self._port_obj.setup_environ_for_server()
     142        server_name = self._filesystem.basename(pywebsocket_script)
     143        self._env = self._port_obj.setup_environ_for_server(server_name)
    146144        self._env['PYTHONPATH'] = (pywebsocket_base + os.path.pathsep + self._env.get('PYTHONPATH', ''))
    147145
Note: See TracChangeset for help on using the changeset viewer.