mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-07-23 09:22:30 +00:00
6da1dfa8f2
Introduces a few ad-hoc modifications to the DAFSA aimed to increase
performance while keeping the data size small.
- The 'first layer' of nodes is extracted out and replaced with a lookup
table. This turns the search for the first character from O(n) to O
(1), and doesn't increase the data size because all first characters
in the set of named character references have the
values 'a'-'z'/'A'-'Z', so a lookup array of exactly 52 elements can
be used. The lookup table stores the cumulative "number" fields that
would be calculated by a linear scan that matches a given node, thus
allowing the unique index to be built-up as normal with a O(1) search
instead of a linear scan.
- The 'second layer' of nodes is also extracted out and searches of the
second layer are done using a bit field of 52 bits (the set bits of
the bit field depend on the first character's value), where each set
bit corresponds to one of 'a'-'z'/'A'-'Z' (similar to the first
layer, the second layer can only contain ASCII alphabetic
characters). The bit field is then re-used (along with an offset) to
get the index into the array of second layer nodes. This technique
ultimately allows for storing the minimum number of nodes in the
second layer, and therefore only increasing the size of the data by
the size of the 'first to second layer link' info which is 52 * 8 =
416 bytes.
- After the second layer, the rest of the data is stored using a
mostly-normal DAFSA, but there are still a few differences:
- The "number" field is cumulative, in the same way that the
first/second layer store a cumulative "number" field. This cuts
down slightly on the amount of work done during the search of a
list of children, and we can get away with it because the
cumulative "number" fields of the remaining nodes in the DAFSA
(after the first and second layer nodes were extracted out) happens
to require few enough bits that we can store the cumulative version
while staying under our 32-bit budget.
- Instead of storing a 'last sibling' flag to denote the end of a
list of children, the length of each node's list of children is
stored. Again, this is mostly done just because there are enough
bits available to do so while keeping the DAFSA node within 32
bits.
- Note: Together, these modifications open up the possibility of
using a binary search instead of a linear search over the
children, but due to the consistently small lengths of the lists
of children in the remaining DAFSA, a linear search actually seems
to be the better option.
The new data size is 24,724 bytes, up from 24,412 bytes (+312, -104 from
the 52 first layer nodes going from 4-bytes to 2-bytes, and +416 from
the addition of the 'first to second layer link' data).
In terms of raw matching speed (outside the context of the tokenizer),
this provides about a 1.72x speedup.
In very named-character-reference-heavy tokenizer benchmarks, this
provides about a 1.05x speedup (the effect of named character reference
matching speed is diluted when benchmarking the tokenizer).
Additionally, fixes the size of the named character reference data when
targeting Windows.
99 lines
4.1 KiB
C++
99 lines
4.1 KiB
C++
/*
|
|
* Copyright (c) 2020, Andreas Kling <andreas@ladybird.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/Assertions.h>
|
|
#include <AK/BuiltinWrappers.h>
|
|
#include <AK/CharacterTypes.h>
|
|
#include <LibWeb/HTML/Parser/Entities.h>
|
|
#include <LibWeb/HTML/Parser/NamedCharacterReferences.h>
|
|
|
|
namespace Web::HTML {
|
|
|
|
static u8 ascii_alphabetic_to_index(u8 c)
|
|
{
|
|
ASSERT(AK::is_ascii_alpha(c));
|
|
return c <= 'Z' ? (c - 'A') : (c - 'a' + 26);
|
|
}
|
|
|
|
bool NamedCharacterReferenceMatcher::try_consume_ascii_char(u8 c)
|
|
{
|
|
switch (m_search_state_tag) {
|
|
case NamedCharacterReferenceMatcher::SearchStateTag::Init: {
|
|
if (!AK::is_ascii_alpha(c))
|
|
return false;
|
|
auto index = ascii_alphabetic_to_index(c);
|
|
m_search_state_tag = NamedCharacterReferenceMatcher::SearchStateTag::FirstToSecondLayer;
|
|
m_search_state = { .first_to_second_layer = g_named_character_reference_first_to_second_layer[index] };
|
|
m_pending_unique_index = g_named_character_reference_first_layer[index].number;
|
|
m_overconsumed_code_points++;
|
|
return true;
|
|
}
|
|
case NamedCharacterReferenceMatcher::SearchStateTag::FirstToSecondLayer: {
|
|
if (!AK::is_ascii_alpha(c))
|
|
return false;
|
|
auto bit_index = ascii_alphabetic_to_index(c);
|
|
if (((1ull << bit_index) & m_search_state.first_to_second_layer.mask) == 0)
|
|
return false;
|
|
|
|
// Get the second layer node by re-using the first_to_second_layer.mask.
|
|
// For example, if the first character is 'n' and the second character is 'o':
|
|
//
|
|
// This is the first_to_second_layer.mask when the first character is 'n':
|
|
// 0001111110110110111111111100001000100000100001000000
|
|
// └ bit_index of 'o'
|
|
//
|
|
// Create a mask where all of the less significant bits than the
|
|
// bit index of the current character ('o') are set:
|
|
// 0000000000001111111111111111111111111111111111111111
|
|
// └ bit_index of 'o'
|
|
//
|
|
// Bitwise AND this new mask with the first_to_second_layer.mask
|
|
// to get only the set bits less significant than the bit index of the
|
|
// current character:
|
|
// 0000000000000110111111111100001000100000100001000000
|
|
//
|
|
// Take the popcount of this to get the index of the node within the
|
|
// second layer. In this case, there are 16 bits set, so the index
|
|
// of 'o' in the second layer is first_to_second_layer.second_layer_offset + 16.
|
|
u64 mask = (1ull << bit_index) - 1;
|
|
u8 char_index = AK::popcount(m_search_state.first_to_second_layer.mask & mask);
|
|
auto const& node = g_named_character_reference_second_layer[m_search_state.first_to_second_layer.second_layer_offset + char_index];
|
|
|
|
m_pending_unique_index += node.number;
|
|
m_overconsumed_code_points++;
|
|
if (node.end_of_word) {
|
|
m_pending_unique_index++;
|
|
m_last_matched_unique_index = m_pending_unique_index;
|
|
m_ends_with_semicolon = c == ';';
|
|
m_overconsumed_code_points = 0;
|
|
}
|
|
m_search_state_tag = NamedCharacterReferenceMatcher::SearchStateTag::DafsaChildren;
|
|
m_search_state = { .dafsa_children = { &g_named_character_reference_nodes[node.child_index], node.children_len } };
|
|
return true;
|
|
}
|
|
case NamedCharacterReferenceMatcher::SearchStateTag::DafsaChildren: {
|
|
for (auto const& node : m_search_state.dafsa_children) {
|
|
if (node.character == c) {
|
|
m_pending_unique_index += node.number;
|
|
m_overconsumed_code_points++;
|
|
if (node.end_of_word) {
|
|
m_pending_unique_index++;
|
|
m_last_matched_unique_index = m_pending_unique_index;
|
|
m_ends_with_semicolon = c == ';';
|
|
m_overconsumed_code_points = 0;
|
|
}
|
|
m_search_state = { .dafsa_children = { &g_named_character_reference_nodes[node.child_index], node.children_len } };
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
default:
|
|
VERIFY_NOT_REACHED();
|
|
}
|
|
}
|
|
|
|
}
|