Bug 1499170 - Add an atom bit to know whether we're ascii lowercase. r=njn

And thus massively speed up ascii-case-insensitive atom comparisons when both
atoms are lowercase (which is the common case by far).

This removes almost all the slow selector-matching in this page, and it seems
an easier fix than storing the lowercased version of all class-names in quirks
mode in elements and selectors...

Differential Revision: https://phabricator.services.mozilla.com/D10945

--HG--
extra : moz-landing-system : lando

Author: emilio

dom/base/nsAttrValue.cpp

@@ -1169,16 +1169,13 @@ nsAttrValue::Contains(nsAtom* aValue, nsCaseTreatment aCaseSensitive) const
     case eAtomBase:
     {
       nsAtom* atom = GetAtomValue();
-
       if (aCaseSensitive == eCaseMatters) {
         return aValue == atom;
       }
 
       // For performance reasons, don't do a full on unicode case insensitive
       // string comparison. This is only used for quirks mode anyway.
-      return
-        nsContentUtils::EqualsIgnoreASCIICase(nsDependentAtomString(aValue),
-                                              nsDependentAtomString(atom));
+      return nsContentUtils::EqualsIgnoreASCIICase(aValue, atom);
     }
     default:
     {
@@ -1188,16 +1185,11 @@ nsAttrValue::Contains(nsAtom* aValue, nsCaseTreatment aCaseSensitive) const
           return array->Contains(aValue);
         }
 
-        nsDependentAtomString val1(aValue);
-
-        for (RefPtr<nsAtom> *cur = array->Elements(),
-                               *end = cur + array->Length();
-             cur != end; ++cur) {
+        for (RefPtr<nsAtom>& cur : *array) {
           // For performance reasons, don't do a full on unicode case
           // insensitive string comparison. This is only used for quirks mode
           // anyway.
-          if (nsContentUtils::EqualsIgnoreASCIICase(val1,
-                nsDependentAtomString(*cur))) {
+          if (nsContentUtils::EqualsIgnoreASCIICase(aValue, cur)) {
             return true;
           }
         }

dom/base/nsContentUtils.h

@@ -2058,6 +2058,25 @@ class nsContentUtils
 
   static JSContext *GetCurrentJSContext();
 
+  /**
+   * Case insensitive comparison between two atoms.
+   */
+  static bool EqualsIgnoreASCIICase(nsAtom* aAtom1, nsAtom* aAtom2)
+  {
+    if (aAtom1 == aAtom2) {
+      return true;
+    }
+
+    // If both are ascii lowercase already, we know that the slow comparison
+    // below is going to return false.
+    if (aAtom1->IsAsciiLowercase() && aAtom2->IsAsciiLowercase()) {
+      return false;
+    }
+
+    return EqualsIgnoreASCIICase(nsDependentAtomString(aAtom1),
+                                 nsDependentAtomString(aAtom2));
+  }
+
   /**
    * Case insensitive comparison between two strings. However it only ignores
    * case for ASCII characters a-z.

servo/components/style/gecko/regen_atoms.py

@@ -16,8 +16,8 @@
 import build
 
 
-# Matches lines like `GK_ATOM(foo, "foo", 0x12345678, nsStaticAtom, PseudoElementAtom)`.
-PATTERN = re.compile('^GK_ATOM\(([^,]*),[^"]*"([^"]*)",\s*(0x[0-9a-f]+),\s*([^,]*),\s*([^)]*)\)',
+# Matches lines like `GK_ATOM(foo, "foo", 0x12345678, true, nsStaticAtom, PseudoElementAtom)`.
+PATTERN = re.compile('^GK_ATOM\(([^,]*),[^"]*"([^"]*)",\s*(0x[0-9a-f]+),\s*[^,]*,\s*([^,]*),\s*([^)]*)\)',
                      re.MULTILINE)
 FILE = "include/nsGkAtomList.h"
 

servo/components/style/gecko_string_cache/mod.rs

@@ -175,13 +175,19 @@ impl WeakAtom {
     /// Returns whether this atom is static.
     #[inline]
     pub fn is_static(&self) -> bool {
-        unsafe { (*self.as_ptr()).mIsStatic() != 0 }
+        self.0.mIsStatic() != 0
+    }
+
+    /// Returns whether this atom is ascii lowercase.
+    #[inline]
+    fn is_ascii_lowercase(&self) -> bool {
+        self.0.mIsAsciiLowercase() != 0
     }
 
     /// Returns the length of the atom string.
     #[inline]
     pub fn len(&self) -> u32 {
-        unsafe { (*self.as_ptr()).mLength() }
+        self.0.mLength()
     }
 
     /// Returns whether this atom is the empty string.
@@ -199,55 +205,61 @@ impl WeakAtom {
 
     /// Convert this atom to ASCII lower-case
     pub fn to_ascii_lowercase(&self) -> Atom {
+        if self.is_ascii_lowercase() {
+            return self.clone();
+        }
+
         let slice = self.as_slice();
-        match slice
-            .iter()
-            .position(|&char16| (b'A' as u16) <= char16 && char16 <= (b'Z' as u16))
-        {
-            None => self.clone(),
-            Some(i) => {
-                let mut buffer: [u16; 64] = unsafe { mem::uninitialized() };
-                let mut vec;
-                let mutable_slice = if let Some(buffer_prefix) = buffer.get_mut(..slice.len()) {
-                    buffer_prefix.copy_from_slice(slice);
-                    buffer_prefix
-                } else {
-                    vec = slice.to_vec();
-                    &mut vec
-                };
-                for char16 in &mut mutable_slice[i..] {
-                    if *char16 <= 0x7F {
-                        *char16 = (*char16 as u8).to_ascii_lowercase() as u16
-                    }
-                }
-                Atom::from(&*mutable_slice)
-            },
+        let mut buffer: [u16; 64] = unsafe { mem::uninitialized() };
+        let mut vec;
+        let mutable_slice = if let Some(buffer_prefix) = buffer.get_mut(..slice.len()) {
+            buffer_prefix.copy_from_slice(slice);
+            buffer_prefix
+        } else {
+            vec = slice.to_vec();
+            &mut vec
+        };
+        for char16 in &mut *mutable_slice {
+            if *char16 <= 0x7F {
+                *char16 = (*char16 as u8).to_ascii_lowercase() as u16
+            }
         }
+        Atom::from(&*mutable_slice)
     }
 
     /// Return whether two atoms are ASCII-case-insensitive matches
+    #[inline]
     pub fn eq_ignore_ascii_case(&self, other: &Self) -> bool {
         if self == other {
             return true;
         }
 
+        // If we know both atoms are ascii-lowercase, then we can stick with
+        // pointer equality.
+        if self.is_ascii_lowercase() && other.is_ascii_lowercase() {
+            debug_assert!(!self.eq_ignore_ascii_case_slow(other));
+            return false;
+        }
+
+        self.eq_ignore_ascii_case_slow(other)
+    }
+
+    fn eq_ignore_ascii_case_slow(&self, other: &Self) -> bool {
         let a = self.as_slice();
         let b = other.as_slice();
-        a.len() == b.len() && a.iter().zip(b).all(|(&a16, &b16)| {
+
+        if a.len() != b.len() {
+            return false;
+        }
+
+        a.iter().zip(b).all(|(&a16, &b16)| {
             if a16 <= 0x7F && b16 <= 0x7F {
                 (a16 as u8).eq_ignore_ascii_case(&(b16 as u8))
             } else {
                 a16 == b16
             }
         })
     }
-
-    /// Return whether this atom is an ASCII-case-insensitive match for the given string
-    pub fn eq_str_ignore_ascii_case(&self, other: &str) -> bool {
-        self.chars()
-            .map(|r| r.map(|c: char| c.to_ascii_lowercase()))
-            .eq(other.chars().map(|c: char| Ok(c.to_ascii_lowercase())))
-    }
 }
 
 impl fmt::Debug for WeakAtom {

xpcom/ds/Atom.py

@@ -10,6 +10,7 @@ def __init__(self, ident, string, ty="nsStaticAtom"):
         self.ty = ty
         self.atom_type = self.__class__.__name__
         self.hash = hash_string(string)
+        self.is_ascii_lowercase = is_ascii_lowercase(string)
 
 
 class PseudoElementAtom(Atom):
@@ -52,3 +53,12 @@ def hash_string(s):
     for c in s:
         h = wrapping_multiply(GOLDEN_RATIO_U32, rotate_left_5(h) ^ ord(c))
     return h
+
+
+# Returns true if lowercasing this string in an ascii-case-insensitive way
+# would leave the string unchanged.
+def is_ascii_lowercase(s):
+    for c in s:
+        if c >= 'A' and c <= 'Z':
+            return False
+    return True

xpcom/ds/StaticAtoms.py

@@ -2355,9 +2355,9 @@ def generate_nsgkatomlist_h(output, *ignore):
                  "#ifdef small\n"
                  "#undef small\n"
                  "#endif\n\n"
-                 "// GK_ATOM(identifier, string, hash, gecko_type, atom_type)\n" +
-                 "".join(["GK_ATOM(%s, \"%s\", 0x%08x, %s, %s)\n" %
-                            (a.ident, a.string, a.hash, a.ty, a.atom_type)
+                 "// GK_ATOM(identifier, string, hash, is_ascii_lower, gecko_type, atom_type)\n" +
+                 "".join(["GK_ATOM(%s, \"%s\", 0x%08x, %s, %s, %s)\n" %
+                            (a.ident, a.string, a.hash, str(a.is_ascii_lowercase).lower(), a.ty, a.atom_type)
                           for a in STATIC_ATOMS]))
 
 

xpcom/ds/nsAtom.h

@@ -21,9 +21,7 @@ class nsDynamicAtom;
 // This class encompasses both static and dynamic atoms.
 //
 // - In places where static and dynamic atoms can be used, use RefPtr<nsAtom>.
-//   This is by far the most common case. (The exception to this is the HTML5
-//   parser, which does its own weird thing, and uses non-refcounted dynamic
-//   atoms.)
+//   This is by far the most common case.
 //
 // - In places where only static atoms can appear, use nsStaticAtom* to avoid
 //   unnecessary refcounting. This is a moderately common case.
@@ -75,6 +73,13 @@ class nsAtom
   //
   uint32_t hash() const { return mHash; }
 
+  // This function returns true if ToLowercaseASCII would return the string
+  // unchanged.
+  bool IsAsciiLowercase() const
+  {
+    return mIsAsciiLowercase;
+  }
+
   // We can't use NS_INLINE_DECL_THREADSAFE_REFCOUNTING because the refcounting
   // of this type is special.
   MozExternalRefCountType AddRef();
@@ -84,25 +89,29 @@ class nsAtom
 
 protected:
   // Used by nsStaticAtom.
-  constexpr nsAtom(uint32_t aLength, uint32_t aHash)
+  constexpr nsAtom(uint32_t aLength, uint32_t aHash, bool aIsAsciiLowercase)
     : mLength(aLength)
     , mIsStatic(true)
+    , mIsAsciiLowercase(aIsAsciiLowercase)
     , mHash(aHash)
   {}
 
   // Used by nsDynamicAtom.
-  nsAtom(const nsAString& aString, uint32_t aHash)
+  nsAtom(const nsAString& aString,
+         uint32_t aHash,
+         bool aIsAsciiLowercase)
     : mLength(aString.Length())
     , mIsStatic(false)
+    , mIsAsciiLowercase(aIsAsciiLowercase)
     , mHash(aHash)
   {
   }
 
   ~nsAtom() = default;
 
   const uint32_t mLength:30;
-  // NOTE: There's one free bit here.
   const uint32_t mIsStatic:1;
+  const uint32_t mIsAsciiLowercase:1;
   const uint32_t mHash;
 };
 
@@ -123,8 +132,8 @@ class nsStaticAtom : public nsAtom
   // Atom.py and assert in nsAtomTable::RegisterStaticAtoms that the two
   // hashes match.
   constexpr nsStaticAtom(uint32_t aLength, uint32_t aHash,
-                         uint32_t aStringOffset)
-    : nsAtom(aLength, aHash)
+                         uint32_t aStringOffset, bool aIsAsciiLowercase)
+    : nsAtom(aLength, aHash, aIsAsciiLowercase)
     , mStringOffset(aStringOffset)
   {}
 
@@ -167,14 +176,10 @@ class nsDynamicAtom : public nsAtom
 
   // These shouldn't be used directly, even by friend classes. The
   // Create()/Destroy() methods use them.
-  static nsDynamicAtom* CreateInner(const nsAString& aString, uint32_t aHash);
-  nsDynamicAtom(const nsAString& aString, uint32_t aHash);
+  nsDynamicAtom(const nsAString& aString, uint32_t aHash, bool aIsAsciiLowercase);
   ~nsDynamicAtom() {}
 
-  // Creation/destruction is done by friend classes. The first Create() is for
-  // dynamic normal atoms, the second is for dynamic HTML5 atoms.
   static nsDynamicAtom* Create(const nsAString& aString, uint32_t aHash);
-  static nsDynamicAtom* Create(const nsAString& aString);
   static void Destroy(nsDynamicAtom* aAtom);
 
   mozilla::ThreadSafeAutoRefCnt mRefCnt;