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
 
+# We want to sort fields by their alignment sizes. Specifying the exact alignment requirements

[Bugs Nash, 2017/04/28 00:16:51]

Add to the comment where the types hard coded here have come from.

Also perhaps reword to "Heuristic ordering of types from largest to smallest,
used to sort fields by their alignment sizes. Specifying the exact blah blah".  

[shend, 2017/04/28 01:00:31]

done

+# for each type is impossible because it's platform specific. Instead, we will define an ordering
+# on types, from largest alignment size to smallest. This heuristic should work most of the time.
+ALIGNMENT_ORDER = [
+    'FillLayer', 'BorderData',  # Aligns like a void *
+    'double',
+    'LengthBox', 'Length', 'float',
+    '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). If we don't know its alignment, we
+    # assume the worst and put it at the front.
+    known_alignment = [field for field in non_bit_fields if field.type_name in ALIGNMENT_ORDER]

[Bugs Nash, 2017/04/28 00:16:51]

nit: swap these lines so that unknown_alignment comes first (as it does in the
return statement)

[shend, 2017/04/28 01:00:30]

done

+    unknown_alignment = [field for field in non_bit_fields if field.type_name not in ALIGNMENT_ORDER]
+    return unknown_alignment + list(sorted(known_alignment, 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()