LibRegex: Add the literal string search optimisation

This switches to using a simple string equality check if the regex
pattern is strictly a string literal.
Technically this optimisation can also be made on bounded literal
patterns like /[abc]def/ or /abc|def/ as well, but those are
significantly more complex to implement due to our bytecode-only
approach.
This commit is contained in:
Ali Mohammad Pur 2023-07-28 20:59:33 +03:30 committed by Andreas Kling
parent 221c52c696
commit 18f4b6c670
Notes: sideshowbarker 2024-07-17 05:09:48 +09:00
6 changed files with 82 additions and 4 deletions

View File

@ -900,9 +900,8 @@ Vector<CompareTypeAndValuePair> OpCode_Compare::flat_compares() const
result.append({ compare_type, ref });
} else if (compare_type == CharacterCompareType::String) {
auto& length = m_bytecode->at(offset++);
if (length > 0)
result.append({ compare_type, m_bytecode->at(offset) });
StringBuilder str_builder;
for (size_t k = 0; k < length; ++k)
result.append({ CharacterCompareType::Char, m_bytecode->at(offset + k) });
offset += length;
} else if (compare_type == CharacterCompareType::CharClass) {
auto character_class = m_bytecode->at(offset++);

View File

@ -190,6 +190,11 @@ public:
explicit RegexStringView(DeprecatedString&&) = delete;
bool is_string_view() const
{
return m_view.has<StringView>();
}
StringView string_view() const
{
return m_view.get<StringView>();

View File

@ -419,6 +419,26 @@ private:
template<class Parser>
bool Matcher<Parser>::execute(MatchInput const& input, MatchState& state, size_t& operations) const
{
if (m_pattern->parser_result.optimization_data.pure_substring_search.has_value() && input.view.is_string_view()) {
// Yay, we can do a simple substring search!
auto& needle = m_pattern->parser_result.optimization_data.pure_substring_search.value();
if (needle.length() + state.string_position > input.view.length())
return false;
auto haystack = input.view.string_view().substring_view(state.string_position);
if (input.regex_options.has_flag_set(AllFlags::Insensitive)) {
if (!haystack.substring_view(0, needle.length()).equals_ignoring_ascii_case(needle))
return false;
} else {
if (!haystack.starts_with(needle))
return false;
}
state.string_position += needle.length();
state.string_position_in_code_units += needle.length();
return true;
}
BumpAllocatedLinkedList<MatchState> states_to_try_next;
#if REGEX_DEBUG
size_t recursion_level = 0;

View File

@ -231,6 +231,7 @@ public:
private:
void run_optimization_passes();
void attempt_rewrite_loops_as_atomic_groups(BasicBlockList const&);
bool attempt_rewrite_entire_match_as_substring_search(BasicBlockList const&);
};
// free standing functions for match, search and has_match

View File

@ -25,9 +25,13 @@ void Regex<Parser>::run_optimization_passes()
{
parser_result.bytecode.flatten();
auto blocks = split_basic_blocks(parser_result.bytecode);
if (attempt_rewrite_entire_match_as_substring_search(blocks))
return;
// Rewrite fork loops as atomic groups
// e.g. a*b -> (ATOMIC a*)b
attempt_rewrite_loops_as_atomic_groups(split_basic_blocks(parser_result.bytecode));
attempt_rewrite_loops_as_atomic_groups(blocks);
parser_result.bytecode.flatten();
}
@ -520,6 +524,51 @@ static AtomicRewritePreconditionResult block_satisfies_atomic_rewrite_preconditi
return AtomicRewritePreconditionResult::SatisfiedWithEmptyHeader;
}
template<typename Parser>
bool Regex<Parser>::attempt_rewrite_entire_match_as_substring_search(BasicBlockList const& basic_blocks)
{
// If there's no jumps, we can probably rewrite this as a substring search (Compare { string = str }).
if (basic_blocks.size() > 1)
return false;
if (basic_blocks.is_empty()) {
parser_result.optimization_data.pure_substring_search = ""sv;
return true; // Empty regex, sure.
}
auto& bytecode = parser_result.bytecode;
auto is_unicode = parser_result.options.has_flag_set(AllFlags::Unicode);
// We have a single basic block, let's see if it's a series of character or string compares.
StringBuilder final_string;
MatchState state;
while (state.instruction_position < bytecode.size()) {
auto& opcode = bytecode.get_opcode(state);
switch (opcode.opcode_id()) {
case OpCodeId::Compare: {
auto& compare = static_cast<OpCode_Compare const&>(opcode);
for (auto& flat_compare : compare.flat_compares()) {
if (flat_compare.type != CharacterCompareType::Char)
return false;
if (is_unicode || flat_compare.value <= 0x7f)
final_string.append_code_point(flat_compare.value);
else
final_string.append(bit_cast<char>(static_cast<u8>(flat_compare.value)));
}
break;
}
default:
return false;
}
state.instruction_position += opcode.size();
}
parser_result.optimization_data.pure_substring_search = final_string.to_deprecated_string();
return true;
}
template<typename Parser>
void Regex<Parser>::attempt_rewrite_loops_as_atomic_groups(BasicBlockList const& basic_blocks)
{

View File

@ -55,6 +55,10 @@ public:
Token error_token;
Vector<DeprecatedFlyString> capture_groups;
AllOptions options;
struct {
Optional<DeprecatedString> pure_substring_search;
} optimization_data {};
};
explicit Parser(Lexer& lexer)