Add heuristic to order non bit fields in ComputedStyleBase.

third_party/WebKit/Source/build/scripts/make_computed_style_base.py

 #!/usr/bin/env python
 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import math
 import sys
 
 import json5_generator
 import template_expander
 import make_style_builder
 
 from name_utilities import (
     enum_for_css_keyword, enum_type_name, enum_value_name, class_member_name, method_name,
     class_name, join_name
 )
 from collections import defaultdict, OrderedDict
 from itertools import chain
 
+# Heuristic ordering of types from largest to smallest, used to sort fields by their alignment sizes.
+# Specifying the exact alignment sizes for each type is impossible because it's platform specific,
+# so we define an ordering instead.
+# The ordering comes from the data obtained in:
+# https://codereview.chromium.org/2841413002
+# TODO(shend): Put alignment sizes into code form, rather than linking to a CL which may disappear.
+ALIGNMENT_ORDER = [
+    'double',
+    'FillLayer', 'BorderData',  # Aligns like a void * (can be 32 or 64 bits)
+    'LengthBox', 'Length', 'float',
+    'StyleColor', 'Color', 'unsigned', 'int',
+    'short',
+    'char',
+    'bool'
+]
+
 # TODO(shend): Improve documentation and add docstrings.
 
 
 def _flatten_list(x):
     """Flattens a list of lists into a single list."""
     return list(chain.from_iterable(x))
 
 
 def _num_32_bit_words_for_bit_fields(bit_fields):
     """Gets the number of 32 bit unsigned integers needed store a list of bit fields."""
@@ skipping 235 matching lines @@
 
             # TODO(shend): Get rid of the property/nonproperty field roles.
             # If the field has_custom_compare_and_copy, then it does not appear in
             # ComputedStyle::operator== and ComputedStyle::CopyNonInheritedFromCached.
             field_role = 'nonproperty' if property_['has_custom_compare_and_copy'] else 'property'
             fields.append(_create_field(field_role, property_))
 
     return fields
 
 
-def _reorder_fields(fields):
-    """
-    Returns a list of fields ordered to minimise padding.
-    """
-    # Separate out bit fields from non bit fields
-    bit_fields = [field for field in fields if field.is_bit_field]
-    non_bit_fields = [field for field in fields if not field.is_bit_field]
-
+def _reorder_bit_fields(bit_fields):
     # Since fields cannot cross word boundaries, in order to minimize
     # padding, group fields into buckets so that as many buckets as possible
     # are exactly 32 bits. Although this greedy approach may not always
     # produce the optimal solution, we add a static_assert to the code to
     # ensure ComputedStyleBase results in the expected size. If that
     # static_assert fails, this code is falling into the small number of
     # cases that are suboptimal, and may need to be rethought.
     # For more details on packing bit fields to reduce padding, see:
     # http://www.catb.org/esr/structure-packing/#_bitfields
     field_buckets = []
     # Consider fields in descending order of size to reduce fragmentation
     # when they are selected. Ties broken in alphabetical order by name.
     for field in sorted(bit_fields, key=lambda f: (-f.size, f.name)):
         added_to_bucket = False
         # Go through each bucket and add this field if it will not increase
         # the bucket's size to larger than 32 bits. Otherwise, make a new
         # bucket containing only this field.
         for bucket in field_buckets:
             if sum(f.size for f in bucket) + field.size <= 32:
                 bucket.append(field)
                 added_to_bucket = True
                 break
         if not added_to_bucket:
             field_buckets.append([field])
 
+    return _flatten_list(field_buckets)
+
+
+def _reorder_non_bit_fields(non_bit_fields):
+    # A general rule of thumb is to sort members by their alignment requirement
+    # (from biggest aligned to smallest).
+    for field in non_bit_fields:
+        assert field.type_name in ALIGNMENT_ORDER, \
+            "Type {} has unknown alignment. Please update ALIGNMENT_ORDER to include it.".format(field.type_name)
+    return list(sorted(non_bit_fields, key=lambda f: ALIGNMENT_ORDER.index(f.type_name)))
+
+
+def _reorder_fields(fields):
+    """
+    Returns a list of fields ordered to minimise padding.
+    """
+    # Separate out bit fields from non bit fields
+    bit_fields = [field for field in fields if field.is_bit_field]
+    non_bit_fields = [field for field in fields if not field.is_bit_field]
+
     # Non bit fields go first, then the bit fields.
-    return list(non_bit_fields) + _flatten_list(field_buckets)
+    return _reorder_non_bit_fields(non_bit_fields) + _reorder_bit_fields(bit_fields)
 
 
 class ComputedStyleBaseWriter(make_style_builder.StyleBuilderWriter):
     def __init__(self, json5_file_paths):
         # Read CSS properties
         super(ComputedStyleBaseWriter, self).__init__([json5_file_paths[0]])
 
         # Ignore shorthand properties
         for property_ in self._properties.values():
             if property_['field_template'] is not None:
@@ skipping 58 matching lines @@
 
     @template_expander.use_jinja('ComputedStyleBaseConstants.h.tmpl')
     def generate_base_computed_style_constants(self):
         return {
             'properties': self._properties,
             'enums': self._generated_enums,
         }
 
 if __name__ == '__main__':
     json5_generator.Maker(ComputedStyleBaseWriter).main()