# Copyright 2017 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Contains a set of Chrome-specific size queries."""
import logging
import re
import models
class _Grouper:
def __init__(self):
self.groups = []
def Add(self, name, group):
logging.debug('Computed %s (%d syms)', name, len(group))
if group:
sorted_group = group.Sorted()
sorted_group.SetName(name)
self.groups.append(sorted_group)
return group.Inverted()
def Finalize(self, remaining):
self.groups.sort(key=lambda s:(s.name.startswith('Other'), -abs(s.pss)))
if remaining:
stars = remaining.Filter(lambda s: s.name.startswith('*'))
if stars:
remaining = stars.Inverted()
stars = stars.Sorted()
stars.SetName('** Merged Symbols')
self.groups.append(stars)
others_by_path = remaining.GroupedByPath(depth=1).Sorted()
for subgroup in others_by_path:
subgroup.SetName('Other //' + subgroup.name)
self.groups.extend(others_by_path)
logging.debug('Finalized')
return models.SymbolGroup(self.groups)
def _CategorizeByChromeComponent(symbols):
g = _Grouper()
# Put things that filter out a lot of symbols at the beginning where possible
# to optimize speed.
symbols = g.Add('WebRTC', symbols.WhereMatches(r'(?i)webrtc'))
symbols = g.Add('v8', symbols.Filter(
lambda s: s.source_path.startswith('v8/')))
symbols = g.Add('Skia', symbols.Filter(lambda s: 'skia/' in s.source_path))
symbols = g.Add('net', symbols.Filter(
lambda s: s.source_path.startswith('net/')))
symbols = g.Add('media', symbols.Filter(
lambda s: s.source_path.startswith('media/')))
symbols = g.Add('gpu', symbols.Filter(
lambda s: s.source_path.startswith('gpu/')))
symbols = g.Add('cc', symbols.Filter(
lambda s: s.source_path.startswith('cc/')))
symbols = g.Add('base', symbols.Filter(
lambda s: s.source_path.startswith('base/')))
symbols = g.Add('viz', symbols.Filter(
lambda s: s.source_path.startswith('components/viz')))
symbols = g.Add('ui/gfx', symbols.Filter(
lambda s: s.source_path.startswith('ui/gfx/')))
# Next, put non-regex queries, since they're a bit faster.
symbols = g.Add('ICU', symbols.Filter(lambda s: '/icu/' in s.source_path))
symbols = g.Add('Prefetch', symbols.Filter(
lambda s: 'resource_prefetch' in s.source_path))
symbols = g.Add('Password Manager', symbols.Filter(
lambda s: 'password_manager' in s.source_path))
symbols = g.Add('Internals Pages', symbols.Filter(
lambda s: '_internals' in s.source_path))
symbols = g.Add('Autofill', symbols.WhereSourcePathMatches(r'(?i)autofill'))
symbols = g.Add('WebGL', symbols.WhereMatches(r'(?i)webgl'))
symbols = g.Add('WebBluetooth', symbols.WhereMatches(r'(?i)bluetooth'))
symbols = g.Add('WebUSB', symbols.WhereMatches(r'(?i)webusb|(\b|_)usb(\b|_)'))
symbols = g.Add('WebVR', symbols.WhereMatches(
r'{{_gvr_}}|{{_cwebvr_}}|{{_vr_}}'))
symbols = g.Add('FileSystem', symbols.WhereSourcePathMatches(
r'content/.*/fileapi|WebKit/.*/filesystem'))
symbols = g.Add('WebCrypto', symbols.WhereMatches(r'(?i)webcrypto'))
symbols = g.Add('Printing', symbols.WhereMatches(r'printing'))
symbols = g.Add('Cast', symbols.WhereSourcePathMatches(
r'(?i)(\b|_)cast(\b|_)'))
symbols = g.Add('Media Source', symbols.WhereMatches(
r'(?i)mediasource|blink::.*TrackDefault|blink::.*SourceBuffer'))
# XSLT must come before libxml.
symbols = g.Add('XSLT', symbols.WhereMatches(r'(?i)xslt'))
symbols = g.Add('libxml', symbols.Filter(
lambda s: 'libxml' in s.source_path))
# These have some overlap with above, so need to come afterwards.
blink_syms = symbols.WhereSourcePathMatches(r'\b(blink|WebKit)\b')
symbols = blink_syms.Inverted()
blink_generated = blink_syms.WhereSourceIsGenerated()
g.Add('Blink (generated)', blink_generated)
g.Add('Blink (non-generated)', blink_generated.Inverted())
symbols = g.Add('Codecs', symbols.WhereSourcePathMatches(
r'^third_party/(libweb[mp]|libpng|libjpeg_turbo|opus|ffmpeg|libvpx)/'))
symbols = g.Add('Other Third-Party', symbols.Filter(
lambda s: 'third_party' in s.source_path))
return g.Finalize(symbols)
def _CategorizeGenerated(symbols):
g = _Grouper()
# Don't count other symbols or prebuilts.
symbols = symbols.Filter(lambda s: s.section_name != models.SECTION_OTHER and
not s.source_path.endswith('.class'))
# JNI is generated into .h files then #included, so the symbols don't actaully
# appear as "SourceIsGenerated".
# Note: String literals within symbols like "kBaseRegisteredMethods" are not
# being accounted for here because they end up within "** merge strings".
# This could be fixed by assigning them all to proper variables rather
# than having them be inline.
symbols = g.Add('RegisterJNI', symbols.WhereFullNameMatches(
r'Register.*JNIEnv\*\)|RegisteredMethods$'))
symbols = g.Add('gl_bindings_autogen',
symbols.WherePathMatches('gl_bindings_autogen'))
symbols = symbols.WhereSourceIsGenerated()
symbols = g.Add(
'Java Protocol Buffers',
symbols.Filter(lambda s: '__protoc_java.srcjar' in s.source_path))
symbols = g.Add('C++ Protocol Buffers', symbols.Filter(lambda s: (
'/protobuf/' in s.object_path or
s.object_path.endswith('.pbzero.o') or
s.object_path.endswith('.pb.o'))))
mojo_pattern = re.compile(r'\bmojom?\b')
symbols = g.Add(
'Mojo',
symbols.Filter(lambda s: (s.full_name.startswith('mojo::') or mojo_pattern
.search(s.source_path))))
symbols = g.Add('DevTools', symbols.WhereSourcePathMatches(
r'\b(?:protocol|devtools)\b'))
symbols = g.Add('Blink (bindings)', symbols.WherePathMatches(
r'(?:blink|WebKit)/.*bindings'))
symbols = g.Add('Blink (other)', symbols.Filter(lambda s: (
'WebKit' in s.object_path or 'blink/' in s.object_path)))
symbols = g.Add('V8 Builtins', symbols.Filter(lambda s: (
s.source_path.endswith('embedded.S'))))
symbols = g.Add('prepopulated_engines.cc', symbols.Filter(lambda s: (
'prepopulated_engines' in s.object_path)))
symbols = g.Add('Metrics-related code', symbols.Filter(lambda s: (
'/metrics/' in s.object_path)))
symbols = g.Add('gpu_driver_bug_list_autogen.cc', symbols.Filter(lambda s: (
'gpu_driver_bug_list' in s.object_path)))
symbols = g.Add('components/policy', symbols.Filter(lambda s: (
'components/policy' in s.object_path)))
return g.Finalize(symbols)
class CannedQueries:
"""A set of pre-written queries."""
def __init__(self, size_infos):
self._size_infos = size_infos
def _SymbolsArg(self, arg, native_only=False, pak_only=False):
arg = arg if arg is not None else self._size_infos[-1]
if isinstance(arg, models.BaseSizeInfo):
if native_only:
arg = arg.native_symbols
elif pak_only:
arg = arg.pak_symbols
else:
arg = arg.symbols
return arg
def CategorizeGenerated(self, symbols=None):
"""Categorizes symbols that come from generated source files."""
return _CategorizeGenerated(self._SymbolsArg(symbols))
def CategorizeByChromeComponent(self, symbols=None):
"""Groups symbols by component using predefined queries."""
return _CategorizeByChromeComponent(self._SymbolsArg(symbols))
def TemplatesByName(self, symbols=None, depth=0):
"""Lists C++ templates grouped by name."""
symbols = self._SymbolsArg(symbols, native_only=True)
# Call Sorted() twice so that subgroups will be sorted.
# TODO(agrieve): Might be nice to recursively GroupedByName() on these.
return symbols.WhereIsTemplate().Sorted().GroupedByName(depth).Sorted()
def StaticInitializers(self, symbols=None):
"""Lists Static Initializers."""
symbols = self._SymbolsArg(symbols, native_only=True)
# GCC generates "_GLOBAL__" symbols. Clang generates "startup".
return symbols.WhereNameMatches('^startup$|^_GLOBAL__')
def LargeFiles(self, symbols=None, min_size=50 * 1024):
"""Lists source files that are larger than a certain size (default 50kb)."""
symbols = self._SymbolsArg(symbols)
return symbols.GroupedByPath(fallback=None).WherePssBiggerThan(
min_size).Sorted()
def PakByPath(self, symbols=None):
"""Groups .pak.* symbols by path."""
symbols = self._SymbolsArg(symbols, pak_only=True)
return symbols.WhereIsPak().Sorted().GroupedByPath().Sorted()
Codebase Browser
chromium